home *** CD-ROM | disk | FTP | other *** search
/ Linux Cubed Series 3: Developer Tools / Linux Cubed Series 3 - Developer Tools.iso / devel / lang / c / xw2.000 / xw2 / xw / csource / x4.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-12-18  |  129.8 KB  |  4,337 lines
  1.  
  2. /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
  3. /*                                                                           */
  4. /*                                                                           */
  5. /*   Modul X4.C                                                              */
  6. /*                                                                           */
  7. /*                                                                           */
  8. /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
  9.  
  10.  
  11.  
  12. /* Header--------------------------------------------------------------------*/
  13.  
  14. #include "xbw.h"
  15. #include "sys/mman.h"
  16. #include "sys/stat.h"
  17. #include "unistd.h"
  18. #include "fcntl.h"
  19.  
  20.   #ifndef MAP_FILE
  21.   #define MAP_FILE 0
  22.   #endif
  23.  
  24. /* Abkürzungen---------------------------------------------------------------*/
  25.                       /* ---............Nicht möglich  */
  26.                       /* !!!............Noch zu machen */
  27.                       /* ???............unklar         */
  28.                       /* TC3............Turbo-C Version*/
  29.                       /*     GNU........32-Bit Version */
  30.                       /*         X11....X-Window       */
  31.  
  32. /*  ---------------------Compiler-Modelle-----------------------------*/
  33.  
  34.  
  35. /*{{{  XbWFDb_DbgVar(      ***    Eine Datenbank-Variable debuggen*/
  36. void  XbWFDb_DbgVar(XbWDDb_DbIVar  *TV,FILE *fp){
  37.   char *name;
  38.   long adresse;
  39.   long groesse;
  40.   int inhalt;
  41.   int fclos=0;
  42.   if (fp == NULL) {
  43.     fp = XbWSSy_fopen("debug.mto","wt");
  44.     if (fp == NULL) {XbWFTb_HBeep(); return;};
  45.     fclos = 1;
  46.     };
  47.   name = (char*)XbWFDb_GetNam(TV);
  48.   adresse = XbWDDb_C_PtrToDbI(TV,XbWDDb_DbISys);
  49.   groesse = XbWFDb_GetSiz(TV);
  50.   inhalt = ((XbWDDb_DbIInt *)TV)->inh;
  51.  
  52.   switch(TV->tp & XbWDDb_Typ){
  53.     case XbWDDb_Int :
  54.                   inhalt = ((XbWDDb_DbIInt *)TV)->inh;
  55.                   XbWFDb_PrInt(fp,name,adresse,groesse,inhalt);  break;
  56.     case XbWDDb_Dbl : XbWFDb_PrDbl(fp,name,adresse,groesse,TV);       break;
  57.     case XbWDDb_NPtr: XbWFDb_PrPtr(fp,name,adresse,groesse,TV);      break;
  58.     case XbWDDb_IPtr:
  59.                  fprintf(fp,"%5ld\tpi\t%2ldsz\t\"%s\"\t\t==> %lu\n",
  60.                    XbWDDb_C_PtrToDbI(TV,XbWDDb_DbISys),XbWFDb_GetSiz(TV),
  61.                    (char*)XbWFDb_GetNam(TV),((XbWDDb_DbIIPtr *)TV)->inh);
  62.                  break;
  63.     case XbWDDb_GPtr:
  64.                  fprintf(fp,"%5ld\tend of actual group\t%2ldsz\t\"%s\"\t\t==> %lu\t(Pointer to start of actual group)\n",
  65.                    XbWDDb_C_PtrToDbI(TV,XbWDDb_DbISys),XbWFDb_GetSiz(TV),
  66.                    (char*)XbWFDb_GetNam(TV),((XbWDDb_DbIGPtr *)TV)->inh);
  67.                  break;
  68.     case XbWDDb_FPtr:
  69.                  fprintf(fp,"%5ld\tcontinuation pointer\t%2ldsz\t\"%s\"\t\t==> %lu\t(Pointer to continuation of actual group)\n",
  70.                    XbWDDb_C_PtrToDbI(TV,XbWDDb_DbISys),XbWFDb_GetSiz(TV),
  71.                    (char*)XbWFDb_GetNam(TV),((XbWDDb_DbIFPtr *)TV)->inh);
  72.                  break;
  73.     case XbWDDb_Str : XbWFDb_PrStr(fp,name,adresse,groesse,TV);      break;
  74.     default:fprintf(fp," -  (???)\n"); break;
  75.     };
  76.   if (fclos) {fclose(fp); };
  77.   };
  78. /*}}}  */
  79.  
  80. /*{{{  XbWFDb_FindNptr(    ***    Unterroutinen zur Datenbank-Verwaltung*/
  81. XbWDDb_DbIVar  *XbWFDb_FindNptr(XbWDDb_DbIVar  *start,char *name){
  82.   char  *tt;
  83.   if (start == NULL) {
  84.     return(NULL);};
  85.   while (start < (XbWDDb_DbIVar  *)XbWDDb_Dbk->T_ITM_END) {
  86.     if ((start->tp & XbWDDb_Typ) == XbWDDb_NPtr){
  87.       if (XbWFTb_CmpStr((char*)XbWFDb_GetNam(start),name) == 0) {
  88.         return(start);
  89.         };
  90.       };
  91.     tt = (char  *)start;
  92.     tt = tt + (long)XbWFDb_GetSiz(start);
  93.     start = (XbWDDb_DbIVar  *)tt;
  94.     while(((start)->tp & XbWDDb_Typ) == XbWDDb_FPtr) {
  95.       start = ((XbWDDb_DbIVar  *) (
  96.         (char *)(XbWVDb_DbkStrt->T_ITM_SYS)+
  97.         (long)(((XbWDDb_DbINPtr  *)(start))->inh)   ));
  98.       };
  99.     };
  100.   return(NULL);
  101.   };
  102. /*}}}  */
  103. /*{{{  XbWFDb_NextGrp(     ****/
  104. XbWDDb_DbIVar  *XbWFDb_NextGrp(XbWDDb_DbIVar  *start,char *name){
  105.   if (start == NULL) {
  106.     return(NULL);
  107.     };
  108.   while (start != NULL) {
  109.     if ((start->tp & XbWDDb_Typ) == XbWDDb_Str){
  110.       if (name != NULL) {
  111.         if (XbWFTb_CmpStr((char*)XbWFDb_GetStr((XbWDDb_DbIStr  *)start),name) == 0) {
  112.           return(start);
  113.           };
  114.         };
  115.       XbWFDb_ForWd(&start,XbWDDb_DbISys);
  116.       if ((start->tp & XbWDDb_Typ) != XbWDDb_NPtr){ return(NULL); };
  117.       if (((XbWDDb_DbINPtr  *)start)->inh == 0) {return(NULL);};
  118.       start = XbWFDb_CDbIToPtr( ((XbWDDb_DbINPtr  *)start)->inh,XbWDDb_DbISys);
  119.       if (name == NULL) {return(start);};
  120.       };
  121.     };
  122.   return(NULL);
  123.   };
  124. /*}}}  */
  125. /*{{{  XbWFDb_GetInh(      ****/
  126. char  *XbWFDb_GetInh(XbWDDb_DbIVar  *start, int tp){
  127.   if (start == NULL) {
  128.     return(NULL);
  129.     };
  130.   while (start != NULL) {
  131.     while ((start->tp & XbWDDb_Typ) == XbWDDb_NPtr){
  132.       if (((XbWDDb_DbINPtr  *)start)->inh == 0) {return(NULL);};
  133.       start = XbWFDb_CDbIToPtr( ((XbWDDb_DbINPtr  *)start)->inh,XbWDDb_DbISys);
  134.       if (start == NULL) {return(NULL);};
  135.       };
  136.     switch(tp) {
  137.       case XbWDDb_Dbl: if ((start->tp & XbWDDb_Typ) == XbWDDb_Dbl){
  138.                      return((char  *)&((XbWDDb_DbIDbl *)start)->inh);
  139.                      };
  140.                    return(NULL);
  141.       case XbWDDb_Int: if ((start->tp & XbWDDb_Typ) == XbWDDb_Int){
  142.                      return((char  *)&((XbWDDb_DbIInt *)start)->inh);
  143.                      };
  144.                    return(NULL);
  145.       case XbWDDb_Str: if ((start->tp & XbWDDb_Typ) == XbWDDb_Str){
  146.                      return(XbWFDb_GetStr((XbWDDb_DbIStr  *)start));
  147.                      };
  148.                    return(NULL);
  149.       };
  150.     };
  151.   return(NULL);
  152.   };
  153. /*}}}  */
  154. /*{{{  XbWFDb_VarInh(      ****/
  155. char  *XbWFDb_VarInh(XbWDDb_DbIVar  *start, int tp, char *name, int recursiv){
  156.   XbWDDb_DbIVar  *TV;
  157.   TV = start;
  158.   if (TV == NULL) {
  159.     return(NULL);
  160.     };
  161.   if (name == NULL) {
  162.     goto TABvarINHende;
  163.     };
  164.   if (XbWFTb_CmpStr((char*)XbWFDb_GetNam(TV),name) == 0) {
  165.     goto TABvarINHende;
  166.     };
  167.   while ((TV->tp & XbWDDb_Typ) != XbWDDb_GPtr) {
  168.     if (tp == XbWDDb_FPtr) {
  169.       XbWFDb_Fore(&TV,XbWDDb_DbISys);
  170.       }
  171.     else {
  172.       XbWFDb_ForWd(&TV,XbWDDb_DbISys);
  173.       };
  174.     if (XbWFTb_CmpStr((char*)XbWFDb_GetNam(TV),name) == 0) {
  175.       TABvarINHende:;
  176.       if (recursiv) {
  177.         while ((TV->tp & XbWDDb_Typ) == XbWDDb_NPtr){
  178.           if (((XbWDDb_DbINPtr  *)TV)->inh == 0) {return(NULL);};
  179.           TV = XbWFDb_CDbIToPtr( ((XbWDDb_DbINPtr  *)TV)->inh,XbWDDb_DbISys);
  180.           if (TV == NULL) {return(NULL);};
  181.           };
  182.         };
  183.       XbWVDb_ActGrp2 = (XbWDDb_DbIVar  *)TV;
  184.       switch(tp) {
  185.         case XbWDDb_Dbl: if ((TV->tp & XbWDDb_Typ) == XbWDDb_Dbl){
  186.                        return((char  *)&((XbWDDb_DbIDbl *)TV)->inh);
  187.                        };
  188.                      return(NULL);
  189.         case XbWDDb_Int: if ((TV->tp & XbWDDb_Typ) == XbWDDb_Int){
  190.                        return((char  *)&((XbWDDb_DbIInt *)TV)->inh);
  191.                        };
  192.                      return(NULL);
  193.         case XbWDDb_Str: if ((TV->tp & XbWDDb_Typ) == XbWDDb_Str){
  194.                        return(XbWFDb_GetStr((XbWDDb_DbIStr  *)TV));
  195.                        };
  196.                      return(NULL);
  197.         case XbWDDb_FPtr: if ((TV->tp & XbWDDb_Typ) == XbWDDb_FPtr){
  198.                        return((char  *)&((XbWDDb_DbINPtr *)TV)->inh);
  199.                        };
  200.                      return(NULL);
  201.         case XbWDDb_IPtr: if ((TV->tp & XbWDDb_Typ) == XbWDDb_IPtr){
  202.                        return((char  *)&((XbWDDb_DbINPtr *)TV)->inh);
  203.                        };
  204.                      return(NULL);
  205.         case XbWDDb_NPtr: if ((TV->tp & XbWDDb_Typ) == XbWDDb_NPtr){
  206.                        return((char  *)&((XbWDDb_DbINPtr *)TV)->inh);
  207.                        };
  208.                      return(NULL);
  209.         case 0:      return((char *)TV);
  210.         };
  211.       };
  212.     };
  213.   return(NULL);
  214.   };
  215. /*}}}  */
  216. /*{{{  XbWFDb_GetNum(      ****/
  217. double  XbWFDb_GetNum(XbWDDb_DbIVar  *start, char *name, int recursiv){
  218.   XbWDDb_DbIVar  *TV;
  219.   TV = start;
  220.   XbWVDb_FndNum = 1;
  221.   if (TV == NULL) {
  222.     return(0.0);
  223.     };
  224.   if (name == NULL) {
  225.     goto TABvarINHende;
  226.     };
  227.   if (XbWFTb_CmpStr((char*)XbWFDb_GetNam(TV),name) == 0) {
  228.     goto TABvarINHende;
  229.     };
  230.   while ((TV->tp & XbWDDb_Typ) != XbWDDb_GPtr) {
  231.     XbWFDb_ForWd(&TV,XbWDDb_DbISys);
  232.     if (XbWFTb_CmpStr((char*)XbWFDb_GetNam(TV),name) == 0) {
  233.       TABvarINHende:;
  234.       XbWVDb_ActGrp1 = TV;
  235.       if (recursiv) {
  236.         while ((TV->tp & XbWDDb_Typ) == XbWDDb_NPtr){
  237.           if (((XbWDDb_DbINPtr  *)TV)->inh == 0) {return(0.0);};
  238.           TV = XbWFDb_CDbIToPtr( ((XbWDDb_DbINPtr  *)TV)->inh,XbWDDb_DbISys);
  239.           if (TV == NULL) {return(0.0);};
  240.           };
  241.         };
  242.       XbWVDb_AkDbkEl = TV;
  243.       switch(TV->tp & XbWDDb_Typ) {
  244.         case XbWDDb_Int:
  245.         case XbWDDb_Dbl: if ((TV->tp & XbWDDb_Typ) == XbWDDb_Dbl){
  246.                        XbWVDb_FndNum = 0;
  247.                        return((double)((XbWDDb_DbIDbl  *)TV)->inh);
  248.                        };
  249.                      if ((TV->tp & XbWDDb_Typ) == XbWDDb_Int){
  250.                        XbWVDb_FndNum = 0;
  251.                        return((double)((XbWDDb_DbIInt  *)TV)->inh);
  252.                        };
  253.                      return(0.0);
  254.         case XbWDDb_Str:
  255.         case XbWDDb_FPtr:
  256.         case XbWDDb_IPtr:
  257.         case XbWDDb_NPtr:
  258.                      return(0.0);
  259.         };
  260.       };
  261.     };
  262.   return(0.0);
  263.   };
  264. /*}}}  */
  265. /*{{{  XbWFDb_PutNum(      ****/
  266. char  *XbWFDb_PutNum(XbWDDb_DbIVar  *start, char *name, int recursiv, double zz){
  267.   XbWDDb_DbIVar  *TV;
  268.   TV = start;
  269.   if (TV == NULL) {
  270.     return(NULL);
  271.     };
  272.   if (name == NULL) {
  273.     goto TABvarINHende;
  274.     };
  275.   if (XbWFTb_CmpStr((char*)XbWFDb_GetNam(TV),name) == 0) {
  276.     goto TABvarINHende;
  277.     };
  278.   while ((TV->tp & XbWDDb_Typ) != XbWDDb_GPtr) {
  279.     XbWFDb_ForWd(&TV,XbWDDb_DbISys);
  280.     if (XbWFTb_CmpStr((char*)XbWFDb_GetNam(TV),name) == 0) {
  281.       TABvarINHende:;
  282.       XbWVDb_ActGrp1 = TV;
  283.       if (recursiv) {
  284.         while ((TV->tp & XbWDDb_Typ) == XbWDDb_NPtr){
  285.           if (((XbWDDb_DbINPtr  *)TV)->inh == 0) {return(NULL);};
  286.           TV = XbWFDb_CDbIToPtr(((XbWDDb_DbINPtr  *)TV)->inh,XbWDDb_DbISys);
  287.           if (TV == NULL) {return(NULL);};
  288.           };
  289.         };
  290.       XbWVDb_AkDbkEl = TV;
  291.       switch(TV->tp & XbWDDb_Typ) {
  292.         case XbWDDb_Int:
  293.         case XbWDDb_Dbl: if ((TV->tp & XbWDDb_Typ) == XbWDDb_Dbl){
  294.                         ((XbWDDb_DbIDbl  *)TV)->inh = zz;
  295.                        return((char  *)&((XbWDDb_DbIDbl *)TV)->inh);
  296.                        };
  297.                      if ((TV->tp & XbWDDb_Typ) == XbWDDb_Int){
  298.                        ((XbWDDb_DbIInt  *)TV)->inh = (int)zz;
  299.                        return((char  *)&((XbWDDb_DbIInt *)TV)->inh);
  300.                        };
  301.                      return(NULL);
  302.         case XbWDDb_Str:
  303.         case XbWDDb_FPtr:
  304.         case XbWDDb_IPtr:
  305.         case XbWDDb_NPtr:
  306.                      return(0);
  307.         };
  308.       };
  309.     };
  310.   return(0);
  311.   };
  312. /*}}}  */
  313. /*{{{  XbWFDb_PutStr(      ****/
  314. int  XbWFDb_PutStr(XbWDDb_DbIVar  *start, char *name, int recursiv, char *sstr){
  315.   XbWDDb_DbIVar  *TV;
  316.   TV = start;
  317.   if (TV == NULL) {
  318.     return(0);
  319.     };
  320.   if (XbWFTb_CmpStr((char*)XbWFDb_GetNam(TV),name) == 0) {
  321.     goto TABvarINHende;
  322.     };
  323.   while ((TV->tp & XbWDDb_Typ) != XbWDDb_GPtr) {
  324.     XbWFDb_ForWd(&TV,XbWDDb_DbISys);
  325.     if (XbWFTb_CmpStr((char*)XbWFDb_GetNam(TV),name) == 0) {
  326.       XbWVDb_ActGrp1 = TV;
  327.       if (recursiv) {
  328.         while ((TV->tp & XbWDDb_Typ) == XbWDDb_NPtr){
  329.           if (((XbWDDb_DbINPtr  *)TV)->inh == 0) {return(0);};
  330.           TV = XbWFDb_CDbIToPtr( ((XbWDDb_DbINPtr  *)TV)->inh,XbWDDb_DbISys);
  331.           if (TV == NULL) {return(0);};
  332.           };
  333.         };
  334.       TABvarINHende:;
  335.       XbWVDb_AkDbkEl = TV;
  336.       switch(TV->tp & XbWDDb_Typ) {
  337.         case XbWDDb_Str: {
  338.                        int len;
  339.                        XbWDDb_DbIStr  *TS;
  340.                        TS = (XbWDDb_DbIStr  *)TV;
  341.                        len = strlen(sstr);
  342.                        if (len < TS->len * 2) {
  343.                          strcpy((char*)&(TS->nmi[(TS->tp & XbWDDb_NLen)]),sstr);
  344.                          return(1);
  345.                          };
  346.                        XbWSPu_Alarm("Cannot set string because not enough space!");
  347.                        };
  348.                      return(0);
  349.         };
  350.       };
  351.     };
  352.   return(0);
  353.   };
  354. /*}}}  */
  355. /*{{{  XbWFDb_GtEOT(       ****/
  356. void  *XbWFDb_GtEOT(void){
  357.   return(XbWDDb_Dbk->T_ITM_END);
  358.   };
  359. /*}}}  */
  360. /*{{{  XbWFDb_Add(         ****/
  361. void  *XbWFDb_Add(long size){
  362.   XbWVDb_DbkStrt->T_ITM_END =
  363.     (void *)((char *)(XbWVDb_DbkStrt->T_ITM_END)+(long)size);
  364.   return(XbWDDb_Dbk->T_ITM_END);
  365.   };
  366. /*}}}  */
  367. /*{{{  XbWFDb_GetSiz(      ****/
  368. long  XbWFDb_GetSiz(XbWDDb_DbIVar  *TV){
  369.   switch(TV->tp & XbWDDb_Typ){
  370.     case XbWDDb_Int :return(sizeof(XbWDDb_DbIInt)+((TV->tp)&XbWDDb_NLen)-1);
  371.     case XbWDDb_Dbl :return(sizeof(XbWDDb_DbIDbl)+((TV->tp)&XbWDDb_NLen)-1);
  372.     case XbWDDb_IPtr:return(sizeof(XbWDDb_DbIIPtr)+((TV->tp)&XbWDDb_NLen)-1);
  373.     case XbWDDb_NPtr:return(sizeof(XbWDDb_DbINPtr)+((TV->tp)&XbWDDb_NLen)-1);
  374.     case XbWDDb_FPtr:return(sizeof(XbWDDb_DbIGPtr)+((TV->tp)&XbWDDb_NLen)-1);
  375.     case XbWDDb_GPtr:return(sizeof(XbWDDb_DbIGPtr)+((TV->tp)&XbWDDb_NLen)-1);
  376.     case XbWDDb_Str :return(sizeof(XbWDDb_DbIStr)+(((XbWDDb_DbIStr  *)TV)->len)*2+((((XbWDDb_DbIStr  *)TV)->tp)&XbWDDb_NLen)-1);
  377.     default:return(0x2007FFEl);
  378.     };
  379.   };
  380. /*}}}  */
  381. /*{{{  XbWFDb_GetNam(      ****/
  382. char  *XbWFDb_GetNam(XbWDDb_DbIVar  *TV){
  383.   switch(TV->tp & XbWDDb_Typ){
  384.     case XbWDDb_Int :  strncpy(XbWVDb_AktNam,((XbWDDb_DbIInt   *)TV)->nm,TV->tp & XbWDDb_NLen);
  385.                    XbWVDb_AktNam[TV->tp & XbWDDb_NLen] = 0; break;
  386.     case XbWDDb_Dbl :  strncpy(XbWVDb_AktNam,((XbWDDb_DbIDbl   *)TV)->nm,TV->tp & XbWDDb_NLen);
  387.                    XbWVDb_AktNam[TV->tp & XbWDDb_NLen] = 0; break;
  388.     case XbWDDb_NPtr:  strncpy(XbWVDb_AktNam,((XbWDDb_DbINPtr   *)TV)->nm,TV->tp & XbWDDb_NLen);
  389.                    XbWVDb_AktNam[TV->tp & XbWDDb_NLen] = 0; break;
  390.     case XbWDDb_IPtr:  strncpy(XbWVDb_AktNam,((XbWDDb_DbIIPtr   *)TV)->nm,TV->tp & XbWDDb_NLen);
  391.                    XbWVDb_AktNam[TV->tp & XbWDDb_NLen] = 0; break;
  392.     case XbWDDb_GPtr:  strncpy(XbWVDb_AktNam,((XbWDDb_DbIGPtr   *)TV)->nm,TV->tp & XbWDDb_NLen);
  393.                    XbWVDb_AktNam[TV->tp & XbWDDb_NLen] = 0; break;
  394.     case XbWDDb_FPtr:  strncpy(XbWVDb_AktNam,((XbWDDb_DbIFPtr   *)TV)->nm,TV->tp & XbWDDb_NLen);
  395.                    XbWVDb_AktNam[TV->tp & XbWDDb_NLen] = 0; break;
  396.     case XbWDDb_Str :  strncpy(XbWVDb_AktNam,((XbWDDb_DbIStr   *)TV)->nmi,TV->tp & XbWDDb_NLen);
  397.                    XbWVDb_AktNam[TV->tp & XbWDDb_NLen] = 0; break;
  398.     default:return("!!ERROR!!");
  399.     };
  400.   return((char *)&XbWVDb_AktNam);
  401.   };
  402. /*}}}  */
  403. /*{{{  XbWFDb_CmpStr(      ****/
  404. int  XbWFDb_CmpStr(XbWDDb_DbIVar  *TS,char *snam){
  405.   if (TS == NULL){
  406.     return(-1);
  407.     };
  408.   if ((((XbWDDb_DbIStr  *)TS)->tp & XbWDDb_Typ) != XbWDDb_Str) {
  409.     char sstr[80];
  410.     sprintf(sstr,"ERR: can't compare string conten((XbWDDb_DbIStr  *)TS) of %s !!",
  411.       (char*)XbWFDb_GetNam((XbWDDb_DbIVar  *)((XbWDDb_DbIStr  *)TS)));
  412.     XbWFTb_Error(sstr);
  413.     return(-1);
  414.     };
  415.   return(XbWFTb_CmpStr((char*)XbWFDb_GetNam(TS),snam));
  416.   };
  417. /*}}}  */
  418. /*{{{  XbWFDb_GetStr(      ****/
  419. char  *XbWFDb_GetStr(XbWDDb_DbIStr  *TS){
  420.   if ((TS->tp & XbWDDb_Typ) != XbWDDb_Str) {
  421.     char sstr[80];
  422.     sprintf(sstr,"ERR: can't get string contents of %s !!",
  423.       (char*)XbWFDb_GetNam((XbWDDb_DbIVar  *)TS));
  424.     XbWFTb_Error(sstr);
  425.     return("ERROR");
  426.     };
  427.   return(&(TS->nmi[(TS->tp & XbWDDb_NLen)]));
  428.   };
  429. /*}}}  */
  430. /*{{{  XbWFDb_AppCmd(      ****/
  431. int  XbWFDb_AppCmd(void  *(*p)[]){
  432.   XbWDDb_AppCStr  *pa;
  433.   XbWDDb_DbINPtr  *TV;
  434.   int nl;
  435.  
  436.   pa =  (XbWDDb_AppCStr  *)p; if ((int)(pa->anz) < 2) {return(XbWDMf_NoPara);};
  437.  
  438.   nl =  strlen((char*)(pa->nm));
  439.   if (nl > 15) {nl = 15; };
  440.  
  441.   TV = (XbWDDb_DbINPtr  *)XbWFDb_GtEOT();                          /* Platz belegen */
  442.   TV->tp  = XbWDDb_NPtr | nl;
  443.  
  444.   if (XbWFDb_Add(XbWFDb_GetSiz((XbWDDb_DbIVar  *)TV)) == NULL) {return(1);};
  445.  
  446.   strncpy(TV->nm,(char*)pa->nm,nl);
  447.   if (pa->inh != NULL) {
  448.     ((XbWDDb_DbINPtr  *)TV)->inh = (long)NULL;
  449.     XbWFMf_CompileMF((char*)pa->inh);
  450.     ((XbWDDb_DbINPtr  *)TV)->inh =  XbWDDb_C_PtrToDbI(XbWFDb_GtEOT(),XbWDDb_DbISys);
  451.     TV->tp  = XbWDDb_FPtr | nl;
  452.     }
  453.   else {
  454.     ((XbWDDb_DbINPtr  *)TV)->inh = (long)NULL;
  455.     };
  456.   return(0);
  457.   };
  458. /*}}}  */
  459. /*{{{  XbWFDb_AppStr(      ****/
  460. int  XbWFDb_AppStr(void  *(*p)[], int (*t)[]){
  461.   XbWDDb_AppStr  *pa;
  462.   XbWDDb_DbIStr  *TV;
  463.   int ll,nl;
  464.  
  465.   if ( (int)(*p)[0] == -1){
  466.     puts("\n");
  467.     XbWFSy_bf_printf("Function: \"%s\" Add String VAR-Element)\n",(char*)(*p)[1]);
  468.     puts  ("          3 Parameters");
  469.     printf("Syntax:   %s( (\"VAR-Type\") <Length> (\"Content\") );",(char*)(*p)[1]);
  470.     puts  ("\n");
  471.     puts  ("Params:   VAR-Type is a string, max. 15 chars (\"Name\")");
  472.     puts  ("          Length gives the string space in bytes");
  473.     puts  ("          Content is a string with the content to put in");
  474.     printf("Sample:   \"%s\"( myname 80 (\"Text with spaces\") );",(char*)(*p)[1]);
  475.     return(0);
  476.     };
  477.  
  478.   pa =  (XbWDDb_AppStr  *)p; if ((int)(pa->anz) < 3) {return(XbWDMf_NoPara);};
  479.  
  480.   nl =  strlen((char*)(pa->nm));
  481.   if (nl > 15) {nl = 15; };
  482.  
  483.   if ((int)pa->len) {
  484.     ll = (int)(pa->len)+2;
  485.     }
  486.   else {
  487.     ll = strlen((char*)(pa->inh))+2;
  488.     };
  489.   ll = (ll/2)*2;  if (ll > 254*2) {return(XbWDMf_StrToL);};
  490.  
  491.   TV = (XbWDDb_DbIStr  *)XbWFDb_GtEOT();                          /* Platz belegen */
  492.   TV->tp  = XbWDDb_Str | nl;
  493.  
  494.   TV->len = ll/2;
  495.  
  496.  
  497.   if (XbWFDb_Add(XbWFDb_GetSiz((XbWDDb_DbIVar  *)TV)) == NULL) {return(1);};
  498.  
  499.   strncpy(TV->nmi,(char*)pa->nm,nl);
  500.   if (pa->inh != NULL) {
  501.     strncpy(&(TV->nmi[nl]),(char*)pa->inh,ll);
  502.     TV->nmi[nl+ll-1] = 0;
  503.     }
  504.   else {
  505.     TV->nmi[nl]=0;
  506.     };
  507.   return(0);
  508.   };
  509.  
  510. /*}}}  */
  511. /*{{{  XbWFDb_AppCSt(      ****/
  512. int  XbWFDb_AppCSt(void  *(*p)[],int (*t)[]){
  513.   XbWDDb_AppCStr  *pa;
  514.   XbWDDb_DbIStr  *TV;
  515.   int ll,nl;
  516.  
  517.   if ( (int)(*p)[0] == -1){
  518.     puts("\n");
  519.     XbWFSy_bf_printf("Function: \"%s\" Add Constant String VAR-Element)\n",(char*)(*p)[1]);
  520.     puts  ("          2 Parameters");
  521.     printf("Syntax:   %s( (\"VAR-Type\") (\"Content\") );",(char*)(*p)[1]);
  522.     puts  ("\n");
  523.     puts  ("Params:   VAR-Type is a string, max. 15 chars (\"Name\")");
  524.     puts  ("          Content is a string with the content to put in");
  525.     puts  ("          Length is determined by content length");
  526.     printf("Sample:   \"%s\"( myname (\"Text with spaces\") );",(char*)(*p)[1]);
  527.     return(0);
  528.     };
  529.  
  530.  
  531.   pa =  (XbWDDb_AppCStr  *)p; if ((int)(pa->anz) < 2) {return(XbWDMf_NoPara);};
  532.   nl =  strlen((char*)(pa->nm));
  533.   if (nl > 15) {nl = 15; };
  534.   ll = strlen((char*)(pa->inh))+2;
  535.   ll = (ll/2)*2;  if (ll > 254*2) {return(XbWDMf_StrToL);};
  536.   TV = (XbWDDb_DbIStr  *)XbWFDb_GtEOT();                          /* Platz belegen */
  537.   TV->tp  = XbWDDb_Str | nl; TV->len = ll/2;
  538.   if (XbWFDb_Add(XbWFDb_GetSiz((XbWDDb_DbIVar  *)TV)) == NULL) {return(1);};
  539.   strncpy(TV->nmi,(char*)pa->nm,nl);
  540.   if (pa->inh != NULL) {
  541.     strncpy(&(TV->nmi[nl]),(char*)pa->inh,ll);
  542.     TV->nmi[nl+ll-1] = 0;
  543.     }
  544.   else {
  545.     TV->nmi[nl]=0;
  546.     };
  547.   return(0);
  548.   };
  549. /*}}}  */
  550. /*{{{  XbWFDb_AppInt(      ****/
  551. int  XbWFDb_AppInt(void  *(*p)[],int (*t)[]){
  552.   XbWDDb_AppInt  *pa;
  553.   XbWDDb_DbIInt  *TV;
  554.   int nl;
  555.  
  556.   if ( (int)(*p)[0] == -1){
  557.     puts("\n");
  558.     XbWFSy_bf_printf("Function: \"%s\" Add Integer VAR-Element)\n",(char*)(*p)[1]);
  559.     puts  ("          2 Parameters");
  560.     printf("Syntax:   %s( (\"VAR-Type\") <Content> );",(char*)(*p)[1]);
  561.     puts  ("\n");
  562.     puts  ("Params:   VAR-Type is a string, max. 15 chars (\"Name\")");
  563.     puts  ("          Content is an integer number to put in");
  564.     printf("Sample:   \"%s\"( myname 1234 );",(char*)(*p)[1]);
  565.     return(0);
  566.     };
  567.  
  568.  
  569.   pa = (XbWDDb_AppInt  *)p;
  570.   if ((int)(pa->anz) < 2) {return(XbWDMf_NoPara);};
  571.   TV = (XbWDDb_DbIInt  *)XbWFDb_GtEOT();                          /* Platz belegen */
  572.   nl =  strlen((char*)(pa->nm));
  573.   if (nl > 15) {nl = 15; };
  574.   TV->tp  = XbWDDb_Int | nl;
  575.   if (XbWFDb_Add(XbWFDb_GetSiz((XbWDDb_DbIVar  *)TV)) == NULL) {return(1);};
  576.   strncpy(TV->nm,(char*)pa->nm,nl);
  577.   ((XbWDDb_DbIInt  *)TV)->inh = (int)(pa->inh);
  578.   return(0);
  579.   };
  580. /*}}}  */
  581. /*{{{  XbWFDb_AppDbl(      ****/
  582. int  XbWFDb_AppDbl(void  *(*p)[]){
  583.   XbWDDb_AppDBl  *pa;
  584.   XbWDDb_DbIDbl  *TV;
  585.   int nl;
  586.  
  587.   /* This is an obsolete Function */
  588.  
  589.   pa = (XbWDDb_AppDBl  *)p;
  590.   if ((int)(pa->anz) < 2) {return(XbWDMf_NoPara);};
  591.   TV = (XbWDDb_DbIDbl  *)XbWFDb_GtEOT();                          /* Platz belegen */
  592.   nl =  strlen((char*)(pa->nm));
  593.   if (nl > 15) {nl = 15; };
  594.   TV->tp  = XbWDDb_Dbl | nl;
  595.   if (XbWFDb_Add(XbWFDb_GetSiz((XbWDDb_DbIVar  *)TV)) == NULL) {return(1);};
  596.   strncpy(TV->nm,(char*)pa->nm,nl);
  597.   ((XbWDDb_DbIDbl  *)TV)->inh = (double)atof((char *)(pa->inh));
  598.   return(0);
  599.   };
  600. /*}}}  */
  601. /*{{{  XbWFDb_AppDblVal(      ****/
  602. int  XbWFDb_AppDblVal(void  *(*p)[], double val){
  603.   XbWDDb_AppDBl  *pa;
  604.   XbWDDb_DbIDbl  *TV;
  605.   int nl;
  606.  
  607.   if ( (int)(*p)[0] == -1){
  608.     puts("\n");
  609.     XbWFSy_bf_printf("Function: \"%s\" Add Double VAR-Element)\n",(char*)(*p)[1]);
  610.     puts  ("          2 Parameters");
  611.     printf("Syntax:   %s( (\"VAR-Type\") <Content> );",(char*)(*p)[1]);
  612.     puts  ("\n");
  613.     puts  ("Params:   VAR-Type is a string, max. 15 chars (\"Name\")");
  614.     puts  ("          Content is a floating point number to put in");
  615.     printf("Sample:   \"%s\"( myname 1.234 );",(char*)(*p)[1]);
  616.     return(0);
  617.     };
  618.  
  619.  
  620.   pa = (XbWDDb_AppDBl  *)p;
  621.   if ((int)(pa->anz) < 2) {return(XbWDMf_NoPara);};
  622.   TV = (XbWDDb_DbIDbl  *)XbWFDb_GtEOT();                          /* Platz belegen */
  623.   nl =  strlen((char*)(pa->nm));
  624.   if (nl > 15) {nl = 15; };
  625.   TV->tp  = XbWDDb_Dbl | nl;
  626.   if (XbWFDb_Add(XbWFDb_GetSiz((XbWDDb_DbIVar  *)TV)) == NULL) {return(1);};
  627.   strncpy(TV->nm,(char*)pa->nm,nl);
  628.   ((XbWDDb_DbIDbl  *)TV)->inh = val;
  629.   return(0);
  630.   };
  631. /*}}}  */
  632. /*{{{  XbWFDb_AppNPtr(     ****/
  633. int  XbWFDb_AppNPtr(void  *(*p)[],int (*t)[]){
  634.   XbWDDb_AppNPtr  *pa;
  635.   XbWDDb_DbINPtr  *TV;
  636.   int nl;
  637.  
  638.   if ( (int)(*p)[0] == -1){
  639.     puts("\n");
  640.     XbWFSy_bf_printf("Function: \"%s\" Add Pointer VAR-Element)\n",(char*)(*p)[1]);
  641.     puts  ("          2 Parameters");
  642.     printf("Syntax:   %s( (\"VAR-Type\") Pointer );",(char*)(*p)[1]);
  643.     puts  ("\n");
  644.     puts  ("Params:   VAR-Type is a string, max. 15 chars (\"Name\")");
  645.     puts  ("          Pointer gives Address to put in");
  646.     printf("Sample:   \"%s\"( myname (ptr)OBJ:MyObject.MyVARElement );",(char*)(*p)[1]);
  647.     return(0);
  648.     };
  649.  
  650.  
  651.   pa = (XbWDDb_AppNPtr  *)p;
  652.   if ((int)(pa->anz) < 2) {return(XbWDMf_NoPara);};
  653.   TV = (XbWDDb_DbINPtr  *)XbWFDb_GtEOT();                          /* Platz belegen */
  654.   nl =  strlen((char*)(pa->nm));
  655.   if (nl > 15) {nl = 15; };
  656.   TV->tp  = XbWDDb_NPtr | nl;
  657.   if (XbWFDb_Add(XbWFDb_GetSiz((XbWDDb_DbIVar  *)TV)) == NULL) {return(1);};
  658.   strncpy(TV->nm,(char*)pa->nm,nl);
  659.   if (pa->inh == NULL) {
  660.     ((XbWDDb_DbINPtr  *)TV)->inh = 0;
  661.     }
  662.   else {
  663.     ((XbWDDb_DbINPtr  *)TV)->inh =
  664.      XbWDDb_C_PtrToDbI((char*)(pa->inh),XbWDDb_DbISys);
  665.     };
  666.   return(0);
  667.   };
  668. /*}}}  */
  669. /*{{{  XbWFDb_AppIPtr(        ****/
  670. int  XbWFDb_AppIPtr(void  *(*p)[]){
  671.   XbWDDb_AppIPtr  *pa;
  672.   XbWDDb_DbIIPtr  *TV;
  673.   int nl;
  674.   pa = (XbWDDb_AppIPtr  *)p;
  675.   if ((int)(pa->anz) < 2) {return(XbWDMf_NoPara);};
  676.   TV = (XbWDDb_DbIIPtr  *)XbWFDb_GtEOT();                          /* Platz belegen */
  677.   nl =  strlen((char*)(pa->nm));
  678.   if (nl > 15) {nl = 15; };
  679.   TV->tp  = XbWDDb_NPtr | nl;
  680.   if (XbWFDb_Add(XbWFDb_GetSiz((XbWDDb_DbIVar  *)TV)) == NULL) {return(1);};
  681.   strncpy(TV->nm,(char*)pa->nm,nl);
  682.   if (pa->inh == NULL) {
  683.     ((XbWDDb_DbIIPtr  *)TV)->inh = 0;
  684.     }
  685.   else {
  686.     ((XbWDDb_DbIIPtr  *)TV)->inh =
  687.       XbWDDb_C_PtrToDbI((char*)(pa->inh),XbWDDb_DbISys);
  688.     };
  689.   return(0);
  690.   };
  691. /*}}}  */
  692. /*{{{  XbWFDb_AppGPtr(     ****/
  693. int  XbWFDb_AppGPtr(void  *(*p)[],int (*t)[]){
  694.   XbWDDb_DbIGPtr  *TV;
  695.   TV = (XbWDDb_DbIGPtr  *)XbWFDb_GtEOT();                          /* Platz belegen */
  696.  
  697.   if ( (int)(*p)[0] == -1){
  698.     puts("\n");
  699.     XbWFSy_bf_printf("Function: \"%s\" Add End-Of-Group Pointer VAR-Element)\n",(char*)(*p)[1]);
  700.     puts  ("          No Parameters");
  701.     printf("Syntax:   %s();",(char*)(*p)[1]);
  702.     puts  ("\n");
  703.     return(0);
  704.     };
  705.  
  706.  
  707.  
  708.   TV->tp  = XbWDDb_GPtr;
  709.   if (XbWFDb_Add(XbWFDb_GetSiz((XbWDDb_DbIVar  *)TV)) == NULL) {return(1);};
  710.   ((XbWDDb_DbIGPtr  *)TV)->inh = XbWDDb_C_PtrToDbI((XbWDDb_DbIVar  *)XbWDDb_DbIGrp,XbWDDb_DbISys);
  711.   return(0);
  712.   };
  713. /*}}}  */
  714. /*{{{  XbWFDb_GtPrj(       ****/
  715. XbWDDb_DbIVar  *XbWFDb_GtPrj(char *name){
  716.   XbWDDb_DbIVar  *END;
  717.   XbWDDb_DbIVar  *AP;
  718.   XbWDDb_DbINPtr  *TNP;
  719.   END = (XbWDDb_DbIVar  *)XbWFDb_GtEOT();
  720.   AP = (XbWDDb_DbIVar  *)XbWDDb_DbISys;
  721.   while (AP < END) {
  722.     if ((AP->tp & XbWDDb_Typ) == XbWDDb_Str){
  723.       if (XbWFTb_CmpStr((char*)XbWFDb_GetStr((XbWDDb_DbIStr  *)AP),name) == 0) {
  724.         return(AP);
  725.         };
  726.       }
  727.     else {
  728.       return(NULL);
  729.       };
  730.     XbWFDb_ForWd(&AP,(XbWDDb_DbIVar  *)XbWDDb_DbISys);
  731.     if ((AP->tp & XbWDDb_Typ) == XbWDDb_NPtr){
  732.       if (XbWFTb_CmpStr((char*)XbWFDb_GetNam(AP),"PRJ") == 0) {
  733.         TNP = (XbWDDb_DbINPtr  *)AP;
  734.         if (TNP->inh == 0) {
  735.           return(NULL);
  736.           };
  737.         AP = XbWFDb_CDbIToPtr( ((XbWDDb_DbINPtr  *)TNP)->inh,XbWDDb_DbISys);
  738.         }
  739.       else {
  740.         return(NULL);
  741.         };
  742.       }
  743.     else {
  744.       return(NULL);
  745.       };
  746.     };
  747.   return(NULL);
  748.   };
  749. /*}}}  */
  750. /*{{{  XbWFDb_FindGPtr(    ****/
  751. XbWDDb_DbIVar  *XbWFDb_FindGPtr(XbWDDb_DbIVar  *start, XbWDDb_DbIVar  *IP){
  752.   XbWDDb_DbIVar  *END;
  753.   XbWDDb_DbIVar  *AP;
  754.   END = (XbWDDb_DbIVar  *)XbWDDb_Dbk->T_ITM_END;
  755.   AP = start;
  756.   while (AP < END) {
  757.     if ((AP->tp & XbWDDb_Typ) == XbWDDb_GPtr){
  758.       return(AP);
  759.       };
  760.     XbWFDb_ForWd(&AP,IP);
  761.     };
  762.   return(NULL);
  763.   };
  764. /*}}}  */
  765. /*{{{  XbWFDb_FindGrp(     ****/
  766. XbWDDb_DbIVar  *XbWFDb_FindGrp(char *liste, char *name){
  767.   XbWDDb_DbINPtr  *TV;
  768.   if (liste[0] == 'O'){
  769.     if (strcmp(liste,"OBJ") == 0){
  770.       char sname[6];
  771.       strncpy(sname,name,4);
  772.       sname[4]=0;
  773.       if ((TV = (XbWDDb_DbINPtr  *)XbWFDb_FindNptr(XbWDDb_DbIPrj,"WDW"))==NULL){
  774.         goto nochmal_finden;
  775.         };
  776.       do {
  777.         if (TV->inh){
  778.           TV = (XbWDDb_DbINPtr  *)XbWFDb_CDbIToPtr( ((XbWDDb_DbINPtr  *)TV)->inh,
  779.             XbWDDb_DbISys);
  780.           if (XbWFTb_CmpStr((char*)XbWFDb_GetStr((XbWDDb_DbIStr  *)TV),sname)==0) {
  781.             /*return((XbWDDb_DbIVar  *)TV);*/
  782.             while (strcmp((char*)XbWFDb_GetNam((XbWDDb_DbIVar  *)TV),"obj") != 0){
  783.               XbWFDb_ForWd((XbWDDb_DbIVar  **)&TV,XbWDDb_DbISys);
  784.               };
  785.             if ( ((XbWDDb_DbINPtr  *)TV)->inh == 0){ goto nochmal_finden; };
  786.             do {
  787.               if (TV->inh){
  788.                 TV = (XbWDDb_DbINPtr  *)XbWFDb_CDbIToPtr( ((XbWDDb_DbINPtr  *)TV)->inh,
  789.                   XbWDDb_DbISys);
  790.                 if (name == NULL) {
  791.                   return((XbWDDb_DbIVar  *)TV);
  792.                   };
  793.                 if (XbWFTb_CmpStr((char*)XbWFDb_GetStr((XbWDDb_DbIStr  *)TV),name)==0) {
  794.                   return((XbWDDb_DbIVar  *)TV);
  795.                   };
  796.                 }
  797.               else {TV = NULL;};
  798.               }
  799.             while ((TV!=NULL)&((TV = (XbWDDb_DbINPtr  *)XbWFDb_FindNptr((XbWDDb_DbIVar  *)TV,liste))!= NULL));
  800.             };
  801.           }
  802.         else {TV = NULL;};
  803.         }
  804.       while ((TV!=NULL)&((TV = (XbWDDb_DbINPtr  *)XbWFDb_FindNptr((XbWDDb_DbIVar  *)TV,"WDW"))!= NULL));
  805.       };
  806.     };
  807.  
  808.   nochmal_finden:
  809.   if ((TV = (XbWDDb_DbINPtr  *)XbWFDb_FindNptr(XbWDDb_DbIPrj,liste))==NULL){
  810.     return(NULL);
  811.     };
  812.   do {
  813.     if (TV->inh){
  814.       TV = (XbWDDb_DbINPtr  *)XbWFDb_CDbIToPtr( ((XbWDDb_DbINPtr  *)TV)->inh,
  815.         XbWDDb_DbISys);
  816.       if (name == NULL) {
  817.         return((XbWDDb_DbIVar  *)TV);
  818.         };
  819.       if (XbWFTb_CmpStr((char*)XbWFDb_GetStr((XbWDDb_DbIStr  *)TV),name)==0) {
  820.         return((XbWDDb_DbIVar  *)TV);
  821.         };
  822.       }
  823.     else {TV = NULL;};
  824.     }
  825.   while ((TV!=NULL)&((TV = (XbWDDb_DbINPtr  *)XbWFDb_FindNptr((XbWDDb_DbIVar  *)TV,liste))!= NULL));
  826.   return(NULL);
  827.   };
  828. /*}}}  */
  829. /*{{{  XbWFDb_AppGrp(      ****/
  830. int  XbWFDb_AppGrp(char *liste, char *name){
  831.   XbWDDb_DbINPtr  *TL;
  832.   XbWDDb_DbIPtr *TI;
  833.   XbWDDb_DbIVar  *TV;
  834.   if (XbWFTb_CmpStr(liste,"OBJ") == 0) {
  835.     TI = (XbWDDb_DbIPtr*)XbWVWd_W.obj;
  836.     if (*TI == (long)NULL) { return(1);  };
  837.     if ((TV = XbWFDb_CDbIToPtr(*TI,XbWDDb_DbISys)) == NULL) { return(1);};
  838.     if ((TL = (XbWDDb_DbINPtr *)XbWFDb_NextGrp(TV,name)) == NULL) { return(1);};
  839.     }
  840.   else {
  841.     if ((TL = (XbWDDb_DbINPtr  *)XbWFDb_FindGrp(liste,name))==NULL){return(1);};
  842.     };
  843.   XbWDDb_DbIGrp = (XbWDDb_DbIStr  *)TL;
  844.   if ((TL = (XbWDDb_DbINPtr  *)XbWFDb_FindGPtr((XbWDDb_DbIVar  *)TL,(XbWDDb_DbIVar  *)XbWDDb_DbISys))==NULL) {
  845.     return(1);
  846.     };
  847.   TL->tp = (TL->tp & XbWDDb_NLen) | XbWDDb_FPtr;
  848.   ((XbWDDb_DbINPtr  *)TL)->inh = XbWDDb_C_PtrToDbI((XbWDDb_DbIVar  *)XbWFDb_GtEOT(),XbWDDb_DbISys);
  849.   return(0);
  850.   };
  851. /*}}}  */
  852. /*{{{  XbWFDb_AppFPtr(     ****/
  853. int  XbWFDb_AppFPtr(void  *(*p)[]){
  854.   XbWDDb_AppFPtr  *pa;
  855.   pa = (XbWDDb_AppFPtr  *)p;
  856.   if ((int)(pa->anz) < 2) {return(XbWDMf_NoPara);};
  857.   return(XbWFDb_AppGrp((char*)pa->lnm,(char*)pa->gnm));
  858.   };
  859. /*}}}  */
  860. /*{{{  XbWFDb_AppObj(      ****/
  861. int  XbWFDb_AppObj(void  *(*p)[], int (*t)[]){
  862.   void  *vp[6];
  863.   XbWDDb_DbIVar  *ac_gp;
  864.   XbWDDb_DbIVar  *gv_gp;
  865.   XbWDDb_DbIVar  *sc_gp;
  866.   char *wv,*sstr; int ii,xa,ya,cx,cy;
  867.   char *colortxt=NULL;
  868.  
  869.   if ((int)(*p)[0] < 12) {
  870.     if ( ((int)(*p)[0] >= 8) & ((int)(*p)[0] <= 11)) {
  871.       colortxt = (char*)(*p)[8];
  872.       if (colortxt == NULL){
  873.         return(1);
  874.         };
  875.       }
  876.     else {
  877.       return(1);
  878.       };
  879.     };
  880.   XbWDTb_SetPara(1,"OBJ",NULL,NULL,NULL,NULL); XbWFDb_MarlGrp(&vp);
  881.   XbWDTb_SetPara(3,"OBJ",0,(*p)[1],NULL,NULL); XbWFDb_AppStr(&vp,NULL);
  882.   XbWDTb_SetPara(2,"OBJ",NULL,NULL,NULL,NULL); XbWFDb_AppNPtr(&vp,NULL);
  883.   gv_gp = XbWFDb_FindGrp("OBX","genvars");
  884.   if (gv_gp == NULL) { return(1); };
  885.  
  886.   sstr = (char*)XbWFDb_VarInh(gv_gp,XbWDDb_Str,"WDWName",1);
  887.   if (sstr == NULL) { return(1); };
  888.  
  889.   ac_gp = XbWFDb_FindGrp("WDW",sstr);
  890.  
  891.   wv   = (char*)XbWFDb_GetDbI("WDW",sstr,"WDW");
  892.  
  893.   if (wv == NULL) {
  894.     if (wv == NULL) { return(1); };
  895.     };
  896.  
  897.   XbWDTb_SetPara(2,"W",(void *)wv,NULL,NULL,NULL); XbWFDb_AppNPtr(&vp,NULL);
  898.  
  899.   sc_gp = XbWFDb_FindGrp("SVR","colors");
  900.   ac_gp = XbWFDb_FindGrp("OBJ",(char*)(*p)[1]);
  901.   XbWVDb_AkDbkEl = ac_gp;
  902.  
  903.   cx = XbWFGr_TWidth("M");
  904.   /*{{{  if ((*t)[4] == XbWDMf_VLPar){*/
  905.   if ((*t)[4] == XbWDMf_VLPar){
  906.     XbWDTb_SetPara(2,"X",(void  *)(*p)[4],NULL,NULL,NULL); XbWFDb_AppNPtr(&vp,NULL);
  907.     xa = (int)XbWFDb_GetNum(ac_gp,"X",1);
  908.     }
  909.   else {
  910.     xa = cx*((int)(*p)[4])+3;
  911.     XbWDTb_SetPara(2,"X",xa,NULL,NULL,NULL); XbWFDb_AppInt(&vp,NULL);
  912.     };
  913.   /*}}}  */
  914.  
  915.   cy = XbWFGr_THeight();
  916.   /*{{{  if ((*t)[5] == XbWDMf_VLPar){*/
  917.   if ((*t)[5] == XbWDMf_VLPar){
  918.     XbWDTb_SetPara(2,"Y",(void  *)(*p)[5],NULL,NULL,NULL); XbWFDb_AppNPtr(&vp,NULL);
  919.     ya = (int)XbWFDb_GetNum(ac_gp,"Y",1);
  920.     }
  921.   else {
  922.     ya = cy*((int)(*p)[5]);
  923.     XbWDTb_SetPara(2,"Y",ya,NULL,NULL,NULL); XbWFDb_AppInt(&vp,NULL);
  924.     };
  925.   /*}}}  */
  926.   /*{{{  if ((*t)[6] == XbWDMf_VLPar){*/
  927.   if ((*t)[6] == XbWDMf_VLPar){
  928.     XbWDTb_SetPara(2,"x",(void  *)(*p)[6],NULL,NULL,NULL); XbWFDb_AppNPtr(&vp,NULL);
  929.     }
  930.   else {
  931.     XbWDTb_SetPara(2,"x",(xa+cx*((int)(*p)[6])),NULL,NULL,NULL); XbWFDb_AppInt(&vp,NULL);
  932.     };
  933.   /*}}}  */
  934.   /*{{{  if ((*t)[7] == XbWDMf_VLPar){*/
  935.   if ((*t)[7] == XbWDMf_VLPar){
  936.     XbWDTb_SetPara(2,"y",(void  *)(*p)[7],NULL,NULL,NULL); XbWFDb_AppNPtr(&vp,NULL);
  937.     }
  938.   else {
  939.     XbWDTb_SetPara(2,"y",(ya+cy*((int)(*p)[7])),NULL,NULL,NULL); XbWFDb_AppInt(&vp,NULL);
  940.     };
  941.   /*}}}  */
  942.   if (colortxt == NULL){
  943.     /*{{{  if ((*t)[8] == XbWDMf_VLPar){*/
  944.     if ((*t)[8] == XbWDMf_VLPar){
  945.       XbWDTb_SetPara(2,"b",(void  *)(*p)[8],NULL,NULL,NULL); XbWFDb_AppNPtr(&vp,NULL);
  946.       }
  947.     else {
  948.       ii = (int)XbWFDb_GetNum(sc_gp,(char*)(*p)[8],1);
  949.       XbWDTb_SetPara(2,"b",ii,NULL,NULL,NULL); XbWFDb_AppInt(&vp,NULL);
  950.       };
  951.     /*}}}  */
  952.     /*{{{  if ((*t)[9] == XbWDMf_VLPar){*/
  953.     if ((*t)[9] == XbWDMf_VLPar){
  954.       XbWDTb_SetPara(2,"f",(void  *)(*p)[9],NULL,NULL,NULL); XbWFDb_AppNPtr(&vp,NULL);
  955.       }
  956.     else {
  957.       ii = (int)XbWFDb_GetNum(sc_gp,(char*)(*p)[9],1);
  958.       XbWDTb_SetPara(2,"f",ii,NULL,NULL,NULL); XbWFDb_AppInt(&vp,NULL);
  959.       };
  960.     /*}}}  */
  961.     /*{{{  if ((*t)[10] == XbWDMf_VLPar){*/
  962.     if ((*t)[10] == XbWDMf_VLPar){
  963.       XbWDTb_SetPara(2,"F",(void  *)(*p)[10],NULL,NULL,NULL); XbWFDb_AppNPtr(&vp,NULL);
  964.       }
  965.     else {
  966.       ii = (int)XbWFDb_GetNum(sc_gp,(char*)(*p)[10],1);
  967.       XbWDTb_SetPara(2,"F",ii,NULL,NULL,NULL); XbWFDb_AppInt(&vp,NULL);
  968.       };
  969.     /*}}}  */
  970.     /*{{{  if ((*t)[11] == XbWDMf_VLPar){*/
  971.     if ((*t)[11] == XbWDMf_VLPar){
  972.       XbWDTb_SetPara(2,"t",(void  *)(*p)[11],NULL,NULL,NULL);
  973.       XbWFDb_AppNPtr(&vp,NULL);
  974.       }
  975.     else {
  976.       ii = (int)XbWFDb_GetNum(sc_gp,(char*)(*p)[11],1);
  977.       XbWDTb_SetPara(2,"t",ii,NULL,NULL,NULL); XbWFDb_AppInt(&vp,NULL);
  978.       };
  979.     /*}}}  */
  980.     /*{{{  if ((*t)[2] == XbWDMf_VLPar){*/
  981.     if ((*t)[2] == XbWDMf_VLPar){
  982.       XbWDTb_SetPara(2,"D",(void  *)(*p)[2],NULL,NULL,NULL); XbWFDb_AppNPtr(&vp,NULL);
  983.       }
  984.     else {
  985.       XbWDTb_SetPara(3,"D",0,(char*)(*p)[2],NULL,NULL); XbWFDb_AppStr(&vp,NULL);
  986.       };
  987.     /*}}}  */
  988.     if ((int)(*p)[0] >= 13) {
  989.       /*{{{  if ((*t)[13] == XbWDMf_VLPar){*/
  990.       if ((*t)[13] == XbWDMf_VLPar){
  991.         XbWDTb_SetPara(2,"d",(void  *)(*p)[13],NULL,NULL,NULL); XbWFDb_AppNPtr(&vp,NULL);
  992.         }
  993.       else {
  994.         XbWDTb_SetPara(2,"d",(void *)(*p)[13],NULL,NULL,NULL); XbWFDb_AppInt(&vp,NULL);
  995.         };
  996.       /*}}}  */
  997.       }
  998.     else {
  999.       XbWDTb_SetPara(2,"d",1,NULL,NULL,NULL); XbWFDb_AppInt(&vp,NULL);
  1000.       };
  1001.  
  1002.     if ((int)(*p)[0] >= 14) {
  1003.       /*{{{  if ((*t)[14] == XbWDMf_VLPar){*/
  1004.       if ((*t)[14] == XbWDMf_VLPar){
  1005.         XbWDTb_SetPara(2,"e",(void  *)(*p)[14],NULL,NULL,NULL); XbWFDb_AppNPtr(&vp,NULL);
  1006.         }
  1007.       else {
  1008.         XbWDTb_SetPara(2,"e",(void *)(*p)[14],NULL,NULL,NULL); XbWFDb_AppInt(&vp,NULL);
  1009.         };
  1010.       /*}}}  */
  1011.       }
  1012.     else {
  1013.       XbWDTb_SetPara(2,"e",1,NULL,NULL,NULL); XbWFDb_AppInt(&vp,NULL);
  1014.       };
  1015.  
  1016.     /*{{{  if ((*t)[12] == XbWDMf_VLPar){*/
  1017.     if ((*t)[12] == XbWDMf_VLPar){
  1018.       XbWDTb_SetPara(2,"w",(void  *)(*p)[12],NULL,NULL,NULL); XbWFDb_AppNPtr(&vp,NULL);
  1019.       }
  1020.     else {
  1021.       XbWDTb_SetPara(2,"w",((int)(*p)[12]),NULL,NULL,NULL); XbWFDb_AppInt(&vp,NULL);
  1022.       };
  1023.     /*}}}  */
  1024.     /*{{{  if ((*t)[3] == XbWDMf_VLPar){*/
  1025.     if ((*t)[3] == XbWDMf_VLPar){
  1026.       XbWDTb_SetPara(2,"E",(void  *)(*p)[3],NULL,NULL,NULL); XbWFDb_AppNPtr(&vp,NULL);
  1027.       }
  1028.     else {
  1029.       XbWDTb_SetPara(3,"E",0,(char*)(*p)[3],NULL,NULL); XbWFDb_AppStr(&vp,NULL);
  1030.       };
  1031.     /*}}}  */
  1032.  
  1033.     }
  1034.   else {
  1035.     void *dd;
  1036.     dd = (void*)XbWFDb_GetDbI("COL",colortxt,"Fill");
  1037.     if (dd==NULL){
  1038.       printf("ERROR: cannot find color type COL:%s.Fill !",colortxt);
  1039.       XbWDTb_SetPara(2,"b",8,NULL,NULL,NULL); XbWFDb_AppInt(&vp,NULL);
  1040.       }
  1041.     else {
  1042.       XbWDTb_SetPara(2,"b",dd,NULL,NULL,NULL); XbWFDb_AppNPtr(&vp,NULL);
  1043.       };
  1044.  
  1045.     dd = (void*)XbWFDb_GetDbI("COL",colortxt,"Bright");
  1046.     if (dd==NULL){
  1047.       printf("ERROR: cannot find color type COL:%s.Bright !",colortxt);
  1048.       XbWDTb_SetPara(2,"f",15,NULL,NULL,NULL); XbWFDb_AppInt(&vp,NULL);
  1049.       }
  1050.     else {
  1051.       XbWDTb_SetPara(2,"f",dd,NULL,NULL,NULL); XbWFDb_AppNPtr(&vp,NULL);
  1052.       };
  1053.  
  1054.     dd = (void*)XbWFDb_GetDbI("COL",colortxt,"Dark");
  1055.     if (dd==NULL){
  1056.       printf("ERROR: cannot find color type COL:%s.Dark !",colortxt);
  1057.       XbWDTb_SetPara(2,"F",15,NULL,NULL,NULL); XbWFDb_AppInt(&vp,NULL);
  1058.       }
  1059.     else {
  1060.       XbWDTb_SetPara(2,"F",dd,NULL,NULL,NULL); XbWFDb_AppNPtr(&vp,NULL);
  1061.       };
  1062.  
  1063.     dd = (void*)XbWFDb_GetDbI("COL",colortxt,"Text");
  1064.     if (dd==NULL){
  1065.       printf("ERROR: cannot find color type COL:%s.Text !",colortxt);
  1066.       XbWDTb_SetPara(2,"t",15,NULL,NULL,NULL); XbWFDb_AppInt(&vp,NULL);
  1067.       }
  1068.     else {
  1069.       XbWDTb_SetPara(2,"t",dd,NULL,NULL,NULL); XbWFDb_AppNPtr(&vp,NULL);
  1070.       };
  1071.  
  1072.     /*{{{  if ((*t)[2] == XbWDMf_VLPar){*/
  1073.     if ((*t)[2] == XbWDMf_VLPar){
  1074.       XbWDTb_SetPara(2,"D",(void  *)(*p)[2],NULL,NULL,NULL); XbWFDb_AppNPtr(&vp,NULL);
  1075.       }
  1076.     else {
  1077.       XbWDTb_SetPara(3,"D",0,(char*)(*p)[2],NULL,NULL); XbWFDb_AppStr(&vp,NULL);
  1078.       };
  1079.     /*}}}  */
  1080.     if ((int)(*p)[0] >= 10) {
  1081.       /*{{{  if ((*t)[10] == XbWDMf_VLPar){*/
  1082.       if ((*t)[10] == XbWDMf_VLPar){
  1083.         XbWDTb_SetPara(2,"d",(void  *)(*p)[10],NULL,NULL,NULL); XbWFDb_AppNPtr(&vp,NULL);
  1084.         }
  1085.       else {
  1086.         XbWDTb_SetPara(2,"d",(void *)(*p)[10],NULL,NULL,NULL); XbWFDb_AppInt(&vp,NULL);
  1087.         };
  1088.       /*}}}  */
  1089.       }
  1090.     else {
  1091.       XbWDTb_SetPara(2,"d",1,NULL,NULL,NULL); XbWFDb_AppInt(&vp,NULL);
  1092.       };
  1093.  
  1094.     if ((int)(*p)[0] >= 11) {
  1095.       /*{{{  if ((*t)[11] == XbWDMf_VLPar){*/
  1096.       if ((*t)[11] == XbWDMf_VLPar){
  1097.         XbWDTb_SetPara(2,"e",(void  *)(*p)[11],NULL,NULL,NULL); XbWFDb_AppNPtr(&vp,NULL);
  1098.         }
  1099.       else {
  1100.         XbWDTb_SetPara(2,"e",(void *)(*p)[11],NULL,NULL,NULL); XbWFDb_AppInt(&vp,NULL);
  1101.         };
  1102.       /*}}}  */
  1103.       }
  1104.     else {
  1105.       XbWDTb_SetPara(2,"e",1,NULL,NULL,NULL); XbWFDb_AppInt(&vp,NULL);
  1106.       };
  1107.  
  1108.     if ((int)(*p)[0] > 8){
  1109.       /*{{{  if ((*t)[9] == XbWDMf_VLPar){*/
  1110.       if ((*t)[9] == XbWDMf_VLPar){
  1111.         XbWDTb_SetPara(2,"w",(void  *)(*p)[9],NULL,NULL,NULL); XbWFDb_AppNPtr(&vp,NULL);
  1112.         }
  1113.       else {
  1114.         XbWDTb_SetPara(2,"w",((int)(*p)[9]),NULL,NULL,NULL); XbWFDb_AppInt(&vp,NULL);
  1115.         };
  1116.       /*}}}  */
  1117.       }
  1118.     else {
  1119.       XbWDTb_SetPara(2,"w",(void*)1,NULL,NULL,NULL); XbWFDb_AppInt(&vp,NULL);
  1120.       };
  1121.     /*{{{  if ((*t)[3] == XbWDMf_VLPar){*/
  1122.     if ((*t)[3] == XbWDMf_VLPar){
  1123.       XbWDTb_SetPara(2,"E",(void  *)(*p)[3],NULL,NULL,NULL); XbWFDb_AppNPtr(&vp,NULL);
  1124.       }
  1125.     else {
  1126.       XbWDTb_SetPara(3,"E",0,(char*)(*p)[3],NULL,NULL); XbWFDb_AppStr(&vp,NULL);
  1127.       };
  1128.     /*}}}  */
  1129.     };
  1130.   /*{{{  What's that??*/
  1131.   sstr = (char*)(*p)[2]; /* Display-Mode mit "@" ?? */
  1132.   if (sstr[0] == '@'){
  1133.     XbWDTb_SetPara(2,"@*",NULL,NULL,NULL,NULL);
  1134.     XbWFDb_AppNPtr(&vp,NULL);
  1135.     }
  1136.   else {
  1137.     sstr = (char*)(*p)[3]; /* Editier-Mode mit "@" ?? */
  1138.     if (sstr[0] == '@'){
  1139.       XbWDTb_SetPara(2,"@*",NULL,NULL,NULL,NULL);
  1140.       XbWFDb_AppNPtr(&vp,NULL);
  1141.       };
  1142.     };
  1143.   /*}}}  */
  1144.  
  1145.  
  1146.   XbWFDb_AppGPtr(NULL,NULL);
  1147.   return(0);
  1148.   };
  1149. /*}}}  */
  1150. /*{{{  XbWFDb_AppWdw(      ****/
  1151. int  XbWFDb_AppWdw(void  *(*p)[], int (*t)[]){
  1152.   void  *vp[7];
  1153.   XbWDDb_DbIVar  *ac_gp;
  1154.   XbWDDb_DbIVar  *gv_gp;
  1155.   XbWDDb_DbIVar  *sc_gp;
  1156.   int ii,xa,ya,cx,cy;
  1157.   char *colortxt=NULL;
  1158.   int parameter = 0;
  1159.  
  1160.   #define GETHELPFILE 1
  1161.   #define GETICON     2
  1162.   #define GETCOLORS   4
  1163.   #define GETCOLORGRP 8
  1164.   #define GETCGRP     16
  1165.   /*    1 2 3  4  5     6    7    8   9   10  11 */
  1166.   /* name x y sx sy helpfile icon bkc bfc dfc txc */
  1167.   /* name x y sx sy colorgrp                      */
  1168.  
  1169.   switch ((int)(*p)[0]) {
  1170.     case 6: parameter=GETCGRP; break;
  1171.     case 7: parameter=GETHELPFILE|GETICON; break;
  1172.     case 8: parameter=GETHELPFILE|GETICON|GETCOLORGRP; break;
  1173.     case 11: parameter=GETHELPFILE|GETICON|GETCOLORS; break;
  1174.     default: return(1);
  1175.     };
  1176.  
  1177.   XbWDTb_SetPara(1,"WDW",NULL,NULL,NULL,NULL); XbWFDb_MarlGrp(&vp);
  1178.   XbWDTb_SetPara(3,"WDW",0,(*p)[1],NULL,NULL); XbWFDb_AppStr(&vp,NULL);
  1179.   XbWDTb_SetPara(2,"WDW",NULL,NULL,NULL,NULL); XbWFDb_AppNPtr(&vp,NULL);
  1180.  
  1181.   gv_gp = XbWFDb_FindGrp("OBX","genvars");
  1182.   if (gv_gp == NULL) { return(1); };
  1183.   ac_gp = XbWFDb_FindGrp("WDW",(char*)(*p)[1]);
  1184.   if (ac_gp == NULL) { return(1); };
  1185.  
  1186.   XbWDTb_SetPara(2,"tp",(void*)17,NULL,NULL,NULL); XbWFDb_AppInt(&vp,NULL);
  1187.   XbWDTb_SetPara(2,"layer",(void*)0,NULL,NULL,NULL); XbWFDb_AppInt(&vp,NULL);
  1188.  
  1189.   XbWVDb_AkDbkEl = ac_gp;
  1190.  
  1191.   cx = XbWFGr_TWidth("M");
  1192.   if ((*t)[2] == XbWDMf_VLPar){
  1193.   /*{{{  */
  1194.     XbWDTb_SetPara(2,"nx",(void  *)(*p)[2],NULL,NULL,NULL); XbWFDb_AppNPtr(&vp,NULL);
  1195.     xa = (int)XbWFDb_GetNum(ac_gp,"nx",1);
  1196.     }
  1197.   else {
  1198.     xa = cx*((int)(*p)[2])+3;
  1199.     XbWDTb_SetPara(2,"nx",xa,NULL,NULL,NULL); XbWFDb_AppInt(&vp,NULL);
  1200.     };
  1201.   /*}}}  */
  1202.  
  1203.   cy = XbWFGr_THeight();
  1204.   if ((*t)[3] == XbWDMf_VLPar){
  1205.   /*{{{  */
  1206.     XbWDTb_SetPara(2,"ny",(void  *)(*p)[3],NULL,NULL,NULL); XbWFDb_AppNPtr(&vp,NULL);
  1207.     ya = (int)XbWFDb_GetNum(ac_gp,"ny",1);
  1208.     }
  1209.   else {
  1210.     ya = cy*((int)(*p)[3]);
  1211.     XbWDTb_SetPara(2,"ny",ya,NULL,NULL,NULL); XbWFDb_AppInt(&vp,NULL);
  1212.     };
  1213.   /*}}}  */
  1214.   if ((*t)[4] == XbWDMf_VLPar){
  1215.   /*{{{  */
  1216.     XbWDTb_SetPara(2,"sx",(void  *)(*p)[4],NULL,NULL,NULL); XbWFDb_AppNPtr(&vp,NULL);
  1217.     }
  1218.   else {
  1219.     XbWDTb_SetPara(2,"sx",(cx*((int)(*p)[4])),NULL,NULL,NULL); XbWFDb_AppInt(&vp,NULL);
  1220.     };
  1221.   /*}}}  */
  1222.   if ((*t)[5] == XbWDMf_VLPar){
  1223.   /*{{{  */
  1224.     XbWDTb_SetPara(2,"sy",(void  *)(*p)[5],NULL,NULL,NULL); XbWFDb_AppNPtr(&vp,NULL);
  1225.     }
  1226.   else {
  1227.     XbWDTb_SetPara(2,"sy",(cy*((int)(*p)[5])),NULL,NULL,NULL); XbWFDb_AppInt(&vp,NULL);
  1228.     };
  1229.   /*}}}  */
  1230.  
  1231.   XbWDTb_SetPara(2,"wov",(void*)0,NULL,NULL,NULL); XbWFDb_AppInt(&vp,NULL);
  1232.  
  1233.   if (parameter & GETICON){
  1234.     /*{{{  */
  1235.     sc_gp = XbWFDb_FindGrp("ICN","WdwGroups");
  1236.     if (sc_gp == NULL) { return(1); };
  1237.     if ((*t)[7] == XbWDMf_VLPar){
  1238.       if ((*p)[7] == NULL){
  1239.         XbWDTb_SetPara(2,"icn",1,NULL,NULL,NULL); XbWFDb_AppInt(&vp,NULL);
  1240.         };
  1241.       XbWDTb_SetPara(2,"icn",(void  *)(*p)[7],NULL,NULL,NULL); XbWFDb_AppNPtr(&vp,NULL);
  1242.       }
  1243.     else {
  1244.       XbWDTb_SetPara(2,"icn",(void *)(*p)[7],NULL,NULL,NULL);
  1245.       XbWFDb_AppInt(&vp,NULL);
  1246.       };
  1247.     /*}}}  */
  1248.     }
  1249.   else {
  1250.     XbWDTb_SetPara(2,"icn",1,NULL,NULL,NULL); XbWFDb_AppInt(&vp,NULL);
  1251.     };
  1252.  
  1253.   if (parameter & GETCOLORS){
  1254.     sc_gp = XbWFDb_FindGrp("SVR","colors");
  1255.     if (sc_gp == NULL) { return(1); };
  1256.     if ((*t)[8] == XbWDMf_VLPar){
  1257.     /*{{{  */
  1258.       XbWDTb_SetPara(2,"bkc",(void  *)(*p)[8],NULL,NULL,NULL); XbWFDb_AppNPtr(&vp,NULL);
  1259.       }
  1260.     else {
  1261.       ii = (int)XbWFDb_GetNum(sc_gp,(char*)(*p)[8],1);
  1262.       XbWDTb_SetPara(2,"bkc",ii,NULL,NULL,NULL); XbWFDb_AppInt(&vp,NULL);
  1263.       };
  1264.     /*}}}  */
  1265.     if ((*t)[11] == XbWDMf_VLPar){
  1266.     /*{{{  */
  1267.       XbWDTb_SetPara(2,"txc",(void  *)(*p)[11],NULL,NULL,NULL); XbWFDb_AppNPtr(&vp,NULL);
  1268.       }
  1269.     else {
  1270.       ii = (int)XbWFDb_GetNum(sc_gp,(char*)(*p)[11],1);
  1271.       XbWDTb_SetPara(2,"txc",ii,NULL,NULL,NULL); XbWFDb_AppInt(&vp,NULL);
  1272.       };
  1273.     /*}}}  */
  1274.     if ((*t)[9] == XbWDMf_VLPar){
  1275.     /*{{{  */
  1276.       XbWDTb_SetPara(2,"bfc",(void  *)(*p)[9],NULL,NULL,NULL); XbWFDb_AppNPtr(&vp,NULL);
  1277.       }
  1278.     else {
  1279.       ii = (int)XbWFDb_GetNum(sc_gp,(char*)(*p)[9],1);
  1280.       XbWDTb_SetPara(2,"bfc",ii,NULL,NULL,NULL); XbWFDb_AppInt(&vp,NULL);
  1281.       };
  1282.     /*}}}  */
  1283.     if ((*t)[10] == XbWDMf_VLPar){
  1284.     /*{{{  */
  1285.       XbWDTb_SetPara(2,"dfc",(void  *)(*p)[10],NULL,NULL,NULL); XbWFDb_AppNPtr(&vp,NULL);
  1286.       }
  1287.     else {
  1288.       ii = (int)XbWFDb_GetNum(sc_gp,(char*)(*p)[10],1);
  1289.       XbWDTb_SetPara(2,"dfc",ii,NULL,NULL,NULL); XbWFDb_AppInt(&vp,NULL);
  1290.       };
  1291.     /*}}}  */
  1292.     }
  1293.   else {
  1294.     if (parameter & GETCOLORGRP){
  1295.       /*{{{  */
  1296.       void *dd;
  1297.       colortxt = (char*)(*p)[8];
  1298.       if (colortxt == NULL){
  1299.         return(1);
  1300.         };
  1301.       dd = (void*)XbWFDb_GetDbI("COL",colortxt,"Fill");
  1302.       /*{{{  */
  1303.       if (dd==NULL){
  1304.         printf("ERROR: cannot find color type COL:%s.Fill !",colortxt);
  1305.         XbWDTb_SetPara(2,"bkc",8,NULL,NULL,NULL); XbWFDb_AppInt(&vp,NULL);
  1306.         }
  1307.       else {
  1308.         XbWDTb_SetPara(2,"bkc",dd,NULL,NULL,NULL); XbWFDb_AppNPtr(&vp,NULL);
  1309.         };
  1310.       /*}}}  */
  1311.       dd = (void*)XbWFDb_GetDbI("COL",colortxt,"Text");
  1312.       /*{{{  */
  1313.       if (dd==NULL){
  1314.         printf("ERROR: cannot find color type COL:%s.Text !",colortxt);
  1315.         XbWDTb_SetPara(2,"txc",15,NULL,NULL,NULL); XbWFDb_AppInt(&vp,NULL);
  1316.         }
  1317.       else {
  1318.         XbWDTb_SetPara(2,"txc",dd,NULL,NULL,NULL); XbWFDb_AppNPtr(&vp,NULL);
  1319.         };
  1320.       
  1321.       /*}}}  */
  1322.       dd = (void*)XbWFDb_GetDbI("COL",colortxt,"Bright");
  1323.       /*{{{  */
  1324.       if (dd==NULL){
  1325.         printf("ERROR: cannot find color type COL:%s.Bright !",colortxt);
  1326.         XbWDTb_SetPara(2,"bfc",15,NULL,NULL,NULL); XbWFDb_AppInt(&vp,NULL);
  1327.         }
  1328.       else {
  1329.         XbWDTb_SetPara(2,"bfc",dd,NULL,NULL,NULL); XbWFDb_AppNPtr(&vp,NULL);
  1330.         };
  1331.       
  1332.       /*}}}  */
  1333.       dd = (void*)XbWFDb_GetDbI("COL",colortxt,"Dark");
  1334.       /*{{{  */
  1335.       if (dd==NULL){
  1336.         printf("ERROR: cannot find color type COL:%s.Dark !",colortxt);
  1337.         XbWDTb_SetPara(2,"dfc",15,NULL,NULL,NULL); XbWFDb_AppInt(&vp,NULL);
  1338.         }
  1339.       else {
  1340.         XbWDTb_SetPara(2,"dfc",dd,NULL,NULL,NULL); XbWFDb_AppNPtr(&vp,NULL);
  1341.         };
  1342.       
  1343.       /*}}}  */
  1344.       /*}}}  */
  1345.       }
  1346.     else {
  1347.       if (parameter & GETCGRP){
  1348.         /*{{{  */
  1349.         void *dd;
  1350.         colortxt = (char*)(*p)[6];
  1351.         if (colortxt == NULL){
  1352.           return(1);
  1353.           };
  1354.         dd = (void*)XbWFDb_GetDbI("COL",colortxt,"Fill");
  1355.         /*{{{  */
  1356.         if (dd==NULL){
  1357.           printf("ERROR: cannot find color type COL:%s.Fill !",colortxt);
  1358.           XbWDTb_SetPara(2,"bkc",8,NULL,NULL,NULL); XbWFDb_AppInt(&vp,NULL);
  1359.           }
  1360.         else {
  1361.           XbWDTb_SetPara(2,"bkc",dd,NULL,NULL,NULL); XbWFDb_AppNPtr(&vp,NULL);
  1362.           };
  1363.         /*}}}  */
  1364.         dd = (void*)XbWFDb_GetDbI("COL",colortxt,"Text");
  1365.         /*{{{  */
  1366.         if (dd==NULL){
  1367.           printf("ERROR: cannot find color type COL:%s.Text !",colortxt);
  1368.           XbWDTb_SetPara(2,"txc",15,NULL,NULL,NULL); XbWFDb_AppInt(&vp,NULL);
  1369.           }
  1370.         else {
  1371.           XbWDTb_SetPara(2,"txc",dd,NULL,NULL,NULL); XbWFDb_AppNPtr(&vp,NULL);
  1372.           };
  1373.         
  1374.         /*}}}  */
  1375.         dd = (void*)XbWFDb_GetDbI("COL",colortxt,"Bright");
  1376.         /*{{{  */
  1377.         if (dd==NULL){
  1378.           printf("ERROR: cannot find color type COL:%s.Bright !",colortxt);
  1379.           XbWDTb_SetPara(2,"bfc",15,NULL,NULL,NULL); XbWFDb_AppInt(&vp,NULL);
  1380.           }
  1381.         else {
  1382.           XbWDTb_SetPara(2,"bfc",dd,NULL,NULL,NULL); XbWFDb_AppNPtr(&vp,NULL);
  1383.           };
  1384.         
  1385.         /*}}}  */
  1386.         dd = (void*)XbWFDb_GetDbI("COL",colortxt,"Dark");
  1387.         /*{{{  */
  1388.         if (dd==NULL){
  1389.           printf("ERROR: cannot find color type COL:%s.Dark !",colortxt);
  1390.           XbWDTb_SetPara(2,"dfc",15,NULL,NULL,NULL); XbWFDb_AppInt(&vp,NULL);
  1391.           }
  1392.         else {
  1393.           XbWDTb_SetPara(2,"dfc",dd,NULL,NULL,NULL); XbWFDb_AppNPtr(&vp,NULL);
  1394.           };
  1395.         
  1396.         /*}}}  */
  1397.         /*}}}  */
  1398.         }
  1399.       else {
  1400.         XbWDTb_SetPara(2,"icn",0,NULL,NULL,NULL); XbWFDb_AppInt(&vp,NULL);
  1401.         };
  1402.       };
  1403.     };
  1404.  
  1405.   XbWDTb_SetPara(2,"wfx",(void*)0,NULL,NULL,NULL); XbWFDb_AppInt(&vp,NULL);
  1406.   XbWDTb_SetPara(2,"wfe",(void*)0,NULL,NULL,NULL); XbWFDb_AppInt(&vp,NULL);
  1407.   XbWDTb_SetPara(2,"bd",(void*)0,NULL,NULL,NULL); XbWFDb_AppInt(&vp,NULL);
  1408.   XbWDTb_SetPara(2,"obj",(void*)0,NULL,NULL,NULL); XbWFDb_AppNPtr(&vp,NULL);
  1409.  
  1410.   if (parameter & GETHELPFILE){
  1411.     if ((*p)[6]==NULL){
  1412.       XbWDTb_SetPara(3,"inf",0,"helpfile.inf",NULL,NULL); XbWFDb_AppStr(&vp,NULL);
  1413.       }
  1414.     else {
  1415.       XbWDTb_SetPara(3,"inf",0,(*p)[6],NULL,NULL); XbWFDb_AppStr(&vp,NULL);
  1416.       };
  1417.     }
  1418.   else {
  1419.     XbWDTb_SetPara(3,"inf",0,"helpfile.inf",NULL,NULL); XbWFDb_AppStr(&vp,NULL);
  1420.     };
  1421.   XbWFDb_AppGPtr(NULL,NULL);
  1422.  
  1423.   XbWDTb_SetPara(1,"OBJ",NULL,NULL,NULL,NULL); XbWFDb_MarlGrp(&vp);
  1424.   XbWDTb_SetPara(3,"OBJ",0,(*p)[1],NULL,NULL); XbWFDb_AppStr(&vp,NULL);
  1425.   XbWDTb_SetPara(2,"OBJ",NULL,NULL,NULL,NULL); XbWFDb_AppNPtr(&vp,NULL);
  1426.   XbWDTb_SetPara(3,"W",0,(*p)[1],NULL,NULL); XbWFDb_AppStr(&vp,NULL);
  1427.   XbWDTb_SetPara(2,"X",(void*)0,NULL,NULL,NULL); XbWFDb_AppInt(&vp,NULL);
  1428.   XbWDTb_SetPara(2,"Y",(void*)0,NULL,NULL,NULL); XbWFDb_AppInt(&vp,NULL);
  1429.   XbWDTb_SetPara(2,"x",(void*)0,NULL,NULL,NULL); XbWFDb_AppInt(&vp,NULL);
  1430.   XbWDTb_SetPara(2,"x",(void*)0,NULL,NULL,NULL); XbWFDb_AppInt(&vp,NULL);
  1431.   XbWDTb_SetPara(2,"b",(void*)0,NULL,NULL,NULL); XbWFDb_AppInt(&vp,NULL);
  1432.   XbWDTb_SetPara(2,"f",(void*)0,NULL,NULL,NULL); XbWFDb_AppInt(&vp,NULL);
  1433.   XbWDTb_SetPara(2,"F",(void*)0,NULL,NULL,NULL); XbWFDb_AppInt(&vp,NULL);
  1434.   XbWDTb_SetPara(2,"t",(void*)0,NULL,NULL,NULL); XbWFDb_AppInt(&vp,NULL);
  1435.   XbWDTb_SetPara(3,"D",0,(void*)" ",NULL,NULL); XbWFDb_AppStr(&vp,NULL);
  1436.   XbWDTb_SetPara(2,"d",(void*)0,NULL,NULL,NULL); XbWFDb_AppInt(&vp,NULL);
  1437.   XbWDTb_SetPara(2,"e",(void*)0,NULL,NULL,NULL); XbWFDb_AppInt(&vp,NULL);
  1438.   XbWDTb_SetPara(2,"w",(void*)0,NULL,NULL,NULL); XbWFDb_AppInt(&vp,NULL);
  1439.   XbWDTb_SetPara(3,"E",0,(void*)" ",NULL,NULL); XbWFDb_AppStr(&vp,NULL);
  1440.   XbWFDb_AppGPtr(NULL,NULL);
  1441.  
  1442.   XbWDTb_SetPara(6,"OBJ",(*p)[1],"OBJ","WDW",(*p)[1]); vp[6]="obj";
  1443.   XbWFDb_LinkDbI(&vp);
  1444.  
  1445.   {
  1446.     char *sstr;
  1447.     gv_gp = XbWFDb_FindGrp("OBX","genvars");
  1448.     if (gv_gp == NULL) { return(1); };
  1449.     sstr = (char*)XbWFDb_VarInh(gv_gp,XbWDDb_Str,"WDWName",1);
  1450.     if (sstr == NULL) { return(1); };
  1451.     strcpy(sstr,(char*)(*p)[1]);
  1452.     };
  1453.  
  1454.   XbWDTb_SetPara(1,(*p)[1],NULL,NULL,NULL,NULL);
  1455.   XbWFWd_Select(&vp);
  1456.  
  1457.   return(0);
  1458.   };
  1459. /*}}}  */
  1460. /*{{{  XbWFDb_AppChn(      ****/
  1461. int  XbWFDb_AppChn(void  *(*p)[], int (*t)[]){
  1462.   int ll;
  1463.   void  *vp[6];
  1464.   char sstr[40];
  1465.   char *sptr;
  1466.  
  1467.   if ( (int)(*p)[0] < 2){ return(1);};
  1468.  
  1469.   sptr = (char*)(*p)[1];
  1470.  
  1471.   for (ll = 2; ll <= (int)(*p)[0] ; ll++){
  1472.     sprintf(sstr,"%s%d",sptr,ll-2);
  1473.     switch ( (*t)[ll] ) {
  1474.       case XbWDMf_VLPar:
  1475.          XbWDTb_SetPara(2,sstr,(void  *)(*p)[ll],NULL,NULL,NULL);
  1476.          XbWFDb_AppNPtr(&vp,NULL);
  1477.          break;
  1478.       case XbWDMf_StrPar:
  1479.          XbWDTb_SetPara(3,sstr,0,(void  *)(*p)[ll],NULL,NULL);
  1480.          XbWFDb_AppStr(&vp,NULL);
  1481.          break;
  1482.       case XbWDMf_IntPar:
  1483.          vp[0] = ((void *)2);
  1484.          vp[1] = (void*)(sstr);
  1485.          {
  1486.            int ii;
  1487.            ii = (int)((*p)[ll]);
  1488.            vp[2] = (void*)(ii);
  1489.            };
  1490.          vp[3] = (void*)NULL;
  1491.          vp[4] = (void*)NULL;
  1492.          vp[5] = (void*)NULL;
  1493.          /* XbWDTb_SetPara(2,sstr,(void  *)(*p)[ll],NULL,NULL,NULL); */
  1494.          XbWFDb_AppInt(&vp,NULL);
  1495.          break;
  1496.       case XbWDMf_DblPar:
  1497.          XbWDTb_SetPara(2,sstr,(void  *)(*p)[ll],NULL,NULL,NULL);
  1498.          XbWFDb_AppDbl(&vp);
  1499.          break;
  1500.       };
  1501.     };
  1502.   return(0);
  1503.   };
  1504. /*}}}  */
  1505. /*{{{  XbWFDb_CreateArray( ****/
  1506. int  XbWFDb_CreateArray(void  *(*p)[], int (*t)[]){
  1507.   int xx,yy, xmax=0, ymax=0;
  1508.   void  *vp[6];
  1509.   char sstr[40];
  1510.   char vname[40]="";
  1511.   /* 4 Parameter: Name; X,Y Size; Init-VAR Element */
  1512.  
  1513.   if ( (int)(*p)[0] < 4){ return(1);};
  1514.  
  1515.  
  1516.   switch( (int)(*t)[1] ) {
  1517.     case XbWDMf_StrPar:
  1518.       strcpy(vname,(char*)(XbWFTb_PckTxt((char*)(*p)[1])));
  1519.       break;
  1520.     case XbWDMf_VLPar:
  1521.       {
  1522.         XbWDDb_DbIVar  *QQ;
  1523.         char *vnmp;
  1524.         QQ = (XbWDDb_DbIVar  *)(*p)[1];
  1525.         if (QQ == NULL) { return(1); };
  1526.         vnmp = (char*)XbWFDb_VarInh(QQ,XbWDDb_Str,NULL,1);
  1527.         if (vnmp != NULL) {
  1528.           strcpy(vname,(char*)XbWFTb_PckTxt(vnmp));
  1529.           };
  1530.         };
  1531.       break;
  1532.     };
  1533.   switch( (int)(*t)[2] ) {
  1534.     case XbWDMf_IntPar:
  1535.       ymax = (int)(*p)[2];
  1536.       break;
  1537.     case XbWDMf_VLPar:
  1538.       {
  1539.         XbWDDb_DbIVar  *QQ;
  1540.         QQ = (XbWDDb_DbIVar  *)(*p)[2];
  1541.         if (QQ == NULL) { return(1); };
  1542.         ymax = (int)XbWFDb_GetNum(QQ,NULL,1);
  1543.         };
  1544.       break;
  1545.     };
  1546.   switch( (int)(*t)[3] ) {
  1547.     case XbWDMf_IntPar:
  1548.       xmax = (int)(*p)[3];
  1549.       break;
  1550.     case XbWDMf_VLPar:
  1551.       {
  1552.         XbWDDb_DbIVar  *QQ;
  1553.         QQ = (XbWDDb_DbIVar  *)(*p)[3];
  1554.         if (QQ == NULL) { return(1); };
  1555.         ymax = (int)XbWFDb_GetNum(QQ,NULL,1);
  1556.         };
  1557.       break;
  1558.     };
  1559.  
  1560.   if ((xmax == 0) & (ymax == 0)){
  1561.     return(1);
  1562.     };
  1563.   if (strlen(vname) == 0){
  1564.     return(1);
  1565.     };
  1566.  
  1567.   sprintf(sstr,"  ArraySizeXX");
  1568.   vp[0] = ((void *)2);
  1569.   vp[1] = (void*)(sstr);
  1570.   vp[2] = (void*)(xmax);
  1571.   vp[3] = (void*)NULL;
  1572.   vp[4] = (void*)NULL;
  1573.   vp[5] = (void*)NULL;
  1574.   XbWFDb_AppInt(&vp,NULL);
  1575.   sprintf(sstr,"  ArraySizeYY");
  1576.   vp[0] = ((void *)2);
  1577.   vp[1] = (void*)(sstr);
  1578.   vp[2] = (void*)(ymax);
  1579.   vp[3] = (void*)NULL;
  1580.   vp[4] = (void*)NULL;
  1581.   vp[5] = (void*)NULL;
  1582.   XbWFDb_AppInt(&vp,NULL);
  1583.  
  1584.   for (yy = 0; ((yy < ymax)|(yy==0)) ; yy++){
  1585.     for (xx = 0; ((xx < xmax)|(xx==0)) ; xx++){
  1586.       sprintf(sstr,"%s[%d][%d]",vname,xx,yy);
  1587.       if (!ymax){ sprintf(sstr,"%s[%d]",vname,xx); };
  1588.       if (!xmax){ sprintf(sstr,"%s[%d]",vname,yy); };
  1589.       switch ( (*t)[4] ) {
  1590.         case XbWDMf_VLPar:
  1591.            XbWDTb_SetPara(2,sstr,(void  *)(*p)[4],NULL,NULL,NULL);
  1592.            XbWFDb_AppNPtr(&vp,NULL);
  1593.            break;
  1594.         case XbWDMf_StrPar:
  1595.            XbWDTb_SetPara(3,sstr,0,(void  *)(*p)[4],NULL,NULL);
  1596.            XbWFDb_AppStr(&vp,NULL);
  1597.            break;
  1598.         case XbWDMf_IntPar:
  1599.            vp[0] = ((void *)2);
  1600.            vp[1] = (void*)(sstr);
  1601.            {
  1602.              int ii;
  1603.              ii = (int)((*p)[4]);
  1604.              vp[2] = (void*)(ii);
  1605.              };
  1606.            vp[3] = (void*)NULL;
  1607.            vp[4] = (void*)NULL;
  1608.            vp[5] = (void*)NULL;
  1609.            /* XbWDTb_SetPara(2,sstr,(void  *)(*p)[4],NULL,NULL,NULL); */
  1610.            XbWFDb_AppInt(&vp,NULL);
  1611.            break;
  1612.         case XbWDMf_DblPar:
  1613.            XbWDTb_SetPara(2,sstr,(void  *)(*p)[4],NULL,NULL,NULL);
  1614.            XbWFDb_AppDbl(&vp);
  1615.            break;
  1616.         };
  1617.       };
  1618.     };
  1619.   return(0);
  1620.   };
  1621.  
  1622.  
  1623. /*}}}  */
  1624. /*{{{  XbWFDb_AppTsk(      ****/
  1625. int  XbWFDb_AppTsk(void  *(*p)[], int (*t)[]){
  1626.   void  *vp[6];
  1627.   if ((int)(*p)[0] < 2) {return(1);};
  1628.  
  1629.   if( (*t)[1] == XbWDMf_VLPar){
  1630.     XbWDTb_SetPara(2,"td",(void  *)(*p)[1],NULL,NULL,NULL);
  1631.     XbWFDb_AppNPtr(&vp,NULL);
  1632.     }
  1633.   else {
  1634.     XbWDTb_SetPara(3,"td",0,((char*)(*p)[1]),NULL,NULL);
  1635.     XbWFDb_AppStr(&vp,NULL);
  1636.     };
  1637.   if( (*t)[2] == XbWDMf_VLPar){
  1638.     XbWDTb_SetPara(2,"tn",(void  *)(*p)[2],NULL,NULL,NULL);
  1639.     XbWFDb_AppNPtr(&vp,NULL);
  1640.     }
  1641.   else {
  1642.     XbWDTb_SetPara(3,"tn",0,((char*)(*p)[2]),NULL,NULL);
  1643.     XbWFDb_AppStr(&vp,NULL);
  1644.     };
  1645.   return(0);
  1646.   };
  1647. /*}}}  */
  1648. /*{{{  XbWFDb_AppFloat(    ****/
  1649. int  XbWFDb_AppFloat(void  *(*p)[], int (*t)[]){
  1650.   void  *vp[6];
  1651.   if ((int)(*p)[0] < 3) {return(1);};
  1652.  
  1653.   if( (*t)[1] == XbWDMf_VLPar){
  1654.     XbWDTb_SetPara(2,"fmt",(void  *)(*p)[1],NULL,NULL,NULL);
  1655.     XbWFDb_AppNPtr(&vp,NULL);
  1656.     }
  1657.   else {
  1658.     XbWDTb_SetPara(3,"fmt",0,((char*)(*p)[1]),NULL,NULL);
  1659.     XbWFDb_AppStr(&vp,NULL);
  1660.     };
  1661.   if( (*t)[2] == XbWDMf_VLPar){
  1662.     XbWDTb_SetPara(2,"eha",(void  *)(*p)[2],NULL,NULL,NULL);
  1663.     XbWFDb_AppNPtr(&vp,NULL);
  1664.     }
  1665.   else {
  1666.     XbWDTb_SetPara(3,"eha",0,((char*)(*p)[2]),NULL,NULL);
  1667.     XbWFDb_AppStr(&vp,NULL);
  1668.     };
  1669.   switch( (*t)[3]){
  1670.     case XbWDMf_VLPar:
  1671.       XbWDTb_SetPara(2,"sca",(void  *)(*p)[3],NULL,NULL,NULL);
  1672.       XbWFDb_AppNPtr(&vp,NULL);
  1673.       break;
  1674.     case XbWDMf_StrPar:
  1675.     case XbWDMf_DblPar:
  1676.       XbWDTb_SetPara(3,"sca",((char*)(*p)[3]),NULL,NULL,NULL);
  1677.       XbWFDb_AppDbl(&vp);
  1678.       break;
  1679.     };
  1680.   return(0);
  1681.   };
  1682. /*}}}  */
  1683. /*{{{  XbWFDb_NewGrp(      ****/
  1684. int  XbWFDb_NewGrp(void  *(*p)[],int (*t)[]){
  1685.   void  *vp[6];
  1686.   if ((int)(*p)[0] < 2) {return(1);};
  1687.  
  1688.   XbWDTb_SetPara(1,(*p)[1],NULL,NULL,NULL,NULL); XbWFDb_MarlGrp(&vp);
  1689.   XbWDTb_SetPara(3,(*p)[1],0,(*p)[2],NULL,NULL); XbWFDb_AppStr(&vp,NULL);
  1690.   if (strcmp((char*)(*p)[1],"PRJ") == 0){
  1691.     sprintf(XbWVSy_PrjPath,"\\xw\\x\\app\\%s\\",(char*)(*p)[2]);
  1692.     };
  1693.  
  1694.   XbWDTb_SetPara(2,(*p)[1],NULL,NULL,NULL,NULL); XbWFDb_AppNPtr(&vp,NULL);
  1695.  
  1696.  
  1697.   return(0);
  1698.   };
  1699. /*}}}  */
  1700. /*{{{  XbWFDb_AppLight(    ****/
  1701. int  XbWFDb_AppLight(void  *(*p)[], int (*t)[]){
  1702.   void  *vp[6];
  1703.   if ((int)(*p)[0] < 5) {return(1);};
  1704.  
  1705.   if( (*t)[1] == XbWDMf_VLPar){
  1706.     XbWDTb_SetPara(2,"T",(void  *)(*p)[1],NULL,NULL,NULL);
  1707.     XbWFDb_AppNPtr(&vp,NULL);
  1708.     }
  1709.   else {
  1710.     XbWDTb_SetPara(3,"T",0,((char*)(*p)[1]),NULL,NULL);
  1711.     XbWFDb_AppStr(&vp,NULL);
  1712.     };
  1713.   switch( (*t)[2]){
  1714.     case XbWDMf_VLPar:
  1715.       XbWDTb_SetPara(2,"v",(void  *)(*p)[2],NULL,NULL,NULL);
  1716.       XbWFDb_AppNPtr(&vp,NULL);
  1717.       break;
  1718.     case XbWDMf_StrPar:
  1719.     case XbWDMf_DblPar:
  1720.       XbWDTb_SetPara(2,"v",((char*)(*p)[2]),NULL,NULL,NULL);
  1721.       XbWFDb_AppDbl(&vp);
  1722.       break;
  1723.     case XbWDMf_IntPar:
  1724.       XbWDTb_SetPara(2,"v",((char*)(*p)[2]),NULL,NULL,NULL);
  1725.       XbWFDb_AppInt(&vp,NULL);
  1726.       break;
  1727.     };
  1728.  
  1729.   if( (*t)[3] == XbWDMf_VLPar){
  1730.     XbWDTb_SetPara(2,"1",(void  *)(*p)[3],NULL,NULL,NULL);
  1731.     XbWFDb_AppNPtr(&vp,NULL);
  1732.     }
  1733.   else {
  1734.     XbWDTb_SetPara(3,"1",0,((char*)(*p)[3]),NULL,NULL);
  1735.     XbWFDb_AppStr(&vp,NULL);
  1736.     };
  1737.  
  1738.   if( (*t)[4] == XbWDMf_VLPar){
  1739.     XbWDTb_SetPara(2,"0",(void  *)(*p)[4],NULL,NULL,NULL);
  1740.     XbWFDb_AppNPtr(&vp,NULL);
  1741.     }
  1742.   else {
  1743.     XbWDTb_SetPara(3,"0",0,((char*)(*p)[4]),NULL,NULL);
  1744.     XbWFDb_AppStr(&vp,NULL);
  1745.     };
  1746.  
  1747.   if( (*t)[5] == XbWDMf_VLPar){
  1748.     XbWDTb_SetPara(2,"A",(void  *)(*p)[5],NULL,NULL,NULL);
  1749.     XbWFDb_AppNPtr(&vp,NULL);
  1750.     }
  1751.   else {
  1752.     XbWDTb_SetPara(3,"A",0,((char*)(*p)[5]),NULL,NULL);
  1753.     XbWFDb_AppStr(&vp,NULL);
  1754.     };
  1755.   return(0);
  1756.   };
  1757. /*}}}  */
  1758. /*{{{  XbWFDb_AppBg(       ****/
  1759. int  XbWFDb_AppBg(void  *(*p)[], int (*t)[]){
  1760.   void  *vp[6];
  1761.   if ((int)(*p)[0] < 2) {return(1);};
  1762.   XbWDTb_SetPara(2,"OBJ",((char*)(*p)[1]),NULL,NULL,NULL); XbWFDb_AppFPtr(&vp);
  1763.  
  1764.   if( (*t)[2] == XbWDMf_VLPar){
  1765.     XbWDTb_SetPara(2,"i",(void  *)(*p)[2],NULL,NULL,NULL);
  1766.     XbWFDb_AppNPtr(&vp,NULL);
  1767.     }
  1768.   else {
  1769.     if (strlen((char*)(*p)[2]) > 0) {
  1770.       XbWDTb_SetPara(3,"i",0,((char*)(*p)[2]),NULL,NULL); XbWFDb_AppStr(&vp,NULL);
  1771.       };
  1772.     };
  1773.  
  1774.   if ((int)(*p)[0] >= 3) {
  1775.     switch( (*t)[3] ) {
  1776.       case XbWDMf_VLPar:
  1777.          XbWDTb_SetPara(2,"V",(void  *)(*p)[3],NULL,NULL,NULL);
  1778.          XbWFDb_AppNPtr(&vp,NULL);
  1779.          break;
  1780.       case XbWDMf_StrPar:
  1781.          XbWDTb_SetPara(3,"V",0,(void *)(*p)[3],NULL,NULL);
  1782.          XbWFDb_AppStr(&vp,NULL);
  1783.          break;
  1784.       case XbWDMf_IntPar:
  1785.          { int ii;
  1786.            ii = (int)((*p)[3]);
  1787.            XbWDTb_SetPara(2,"V",(void *)(ii),NULL,NULL,NULL);
  1788.            };
  1789.          XbWFDb_AppInt(&vp,NULL);
  1790.          break;
  1791.       case XbWDMf_DblPar:
  1792.          XbWDTb_SetPara(2,"V",(void *)(*p)[3],NULL,NULL,NULL);
  1793.          XbWFDb_AppDbl(&vp);
  1794.          break;
  1795.       };
  1796.     };
  1797.   return(0);
  1798.   };
  1799.  
  1800.  
  1801. /*}}}  */
  1802. /*{{{  XbWFDb_CPtrToStr(       ****/
  1803. char  *XbWFDb_CPtrToStr(XbWDDb_DbIVar  *TV, XbWDDb_DbIVar  *IP){
  1804.   XbWDDb_DbINPtr  *TL;
  1805.   char gname[16],lname[16],nname[16];
  1806.   char sstr[80];
  1807.   if (TV == NULL) {
  1808.     return("NULL");
  1809.     };
  1810.   if ((TL = (XbWDDb_DbINPtr  *)XbWFDb_FindGPtr((XbWDDb_DbIVar  *)TV,IP)) == NULL){
  1811.     return("???");
  1812.     };
  1813.   if (TL->inh != 0) {
  1814.     TL = (XbWDDb_DbINPtr  *)XbWFDb_CDbIToPtr(((XbWDDb_DbINPtr  *)TL)->inh,IP);
  1815.     strcpy(nname,(char*)XbWFDb_GetNam((XbWDDb_DbIVar  *)TV));
  1816.     strcpy(lname,(char*)XbWFDb_GetNam((XbWDDb_DbIVar  *)TL));
  1817.     strcpy(gname,(char*)XbWFDb_GetStr((XbWDDb_DbIStr  *)TL));
  1818.     sprintf(sstr,"%s:%s.%s",lname,gname,nname);
  1819.     }
  1820.   else {
  1821.     strcpy(nname,(char*)XbWFDb_GetNam((XbWDDb_DbIVar  *)TV));
  1822.     strcpy(lname,(char*)XbWFDb_GetNam((XbWDDb_DbIVar  *)IP));
  1823.     strcpy(gname,(char*)XbWFDb_GetStr((XbWDDb_DbIStr  *)TV));
  1824.     };
  1825.   sprintf(sstr,"%s:%s.%s",lname,gname,nname);
  1826.   return(sstr);
  1827.   };
  1828. /*}}}  */
  1829. /*{{{  XbWFDb_StrToPtr(    ****/
  1830. XbWDDb_DbIVar  *XbWFDb_StrToPtr(char *name){
  1831.   XbWDDb_DbIVar  *TV;
  1832.   char gname[80],lname[80],nname[80];
  1833.  
  1834.   /*  Format : <LISTE>:<GRUPPE>.<Element> */
  1835.  
  1836.   if (name == NULL) {return(0);};
  1837.   if (strchr(name,':') == NULL) {return(0);};
  1838.   if (strchr(name,'.') == NULL) {return(0);};
  1839.  
  1840.   strcpy(lname,name); *((char*)(strchr(lname,':')))=0;
  1841.   strcpy(gname,strchr(name,':')+1); *((char*)(strchr(gname,'.')))=0;
  1842.   strcpy(nname,strchr(name,'.')+1);
  1843.  
  1844.   if ((TV = XbWFDb_FindGrp(lname,gname) ) != NULL) {
  1845.     TV = (XbWDDb_DbIVar *)XbWFDb_VarInh(TV,0,nname,0);
  1846.     };
  1847.   return(TV);
  1848.   };
  1849. /*}}}  */
  1850. /*{{{  XbWFDb_DbIToStr(    ****/
  1851. char  *XbWFDb_DbIToStr(XbWDDb_DbIPtr it, XbWDDb_DbIVar  *IP){
  1852.   return((char*)XbWFDb_CPtrToStr(XbWFDb_CDbIToPtr(it,IP),IP));
  1853.   };
  1854. /*}}}  */
  1855. /*{{{  XbWFDb_StrToDbI(    ****/
  1856. XbWDDb_DbIPtr  XbWFDb_StrToDbI(char *str, XbWDDb_DbIVar  *IP){
  1857.   return(XbWDDb_C_PtrToDbI(XbWFDb_StrToPtr(str),IP));
  1858.   };
  1859. /*}}}  */
  1860. /*{{{  XbWFDb_GetDbI(      ****/
  1861. char  *XbWFDb_GetDbI(char *lname, char *gname, char *nname){
  1862.   XbWDDb_DbIVar  *TV;
  1863.   if ((TV = XbWFDb_FindGrp(lname,gname) ) != NULL) {
  1864.     TV = (XbWDDb_DbIVar *)XbWFDb_VarInh(TV,0,nname,0);
  1865.     };
  1866.   return((char  *)TV);
  1867.   };
  1868. /*}}}  */
  1869. /*{{{  XbWFDb_GetInf(      ****/
  1870. int      XbWFDb_GetInf(XbWDDb_DbIVar  *start, int vnr,
  1871.                        char *vname, int *typ, char **inh, int *ale,
  1872.                        int recursiv){
  1873.   int ii = 0;
  1874.   XbWDDb_DbIVar  *TV;
  1875.   TV = start;
  1876.   if (TV == NULL) {
  1877.     return(0);
  1878.     };
  1879.   if (vnr  == 0) {
  1880.     goto TABvarINHende;
  1881.     };
  1882.   while ((TV->tp & XbWDDb_Typ) != XbWDDb_GPtr) {
  1883.     XbWFDb_ForWd(&TV,XbWDDb_DbISys);
  1884.     if (vnr == -1) {
  1885.       if (XbWFTb_CmpStr((char*)XbWFDb_GetNam(TV),vname) == 0) {
  1886.         ii = vnr;
  1887.         };
  1888.       };
  1889.     if (ii == vnr) {
  1890.       XbWVDb_AkDbkEl = TV;
  1891.       TABvarINHende:;
  1892.       if (recursiv) {
  1893.         while ((TV->tp & XbWDDb_Typ) == XbWDDb_NPtr){
  1894.           if (((XbWDDb_DbINPtr  *)TV)->inh == 0) {return(0);};
  1895.           TV = XbWFDb_CDbIToPtr( ((XbWDDb_DbINPtr  *)TV)->inh,XbWDDb_DbISys);
  1896.           if (TV == NULL) {return(0);};
  1897.           };
  1898.         };
  1899.  
  1900.       *typ = TV->tp & XbWDDb_Typ;
  1901.       if (vname != NULL) {
  1902.         strcpy(vname,(char*)XbWFDb_GetNam(TV));
  1903.         };
  1904.       *ale = 1;
  1905.       switch (*typ) {
  1906.         case XbWDDb_Str:  *ale = ((XbWDDb_DbIStr *)TV)->len * 2;
  1907.                       *inh = (char*)XbWFDb_GetStr((XbWDDb_DbIStr  *)TV); return(1);
  1908.         case XbWDDb_Int:  *inh = (char*)&(((XbWDDb_DbIInt  *)TV)->inh);  return(1);
  1909.         case XbWDDb_Dbl:  *inh = (char*)&(((XbWDDb_DbIDbl  *)TV)->inh);  return(1);
  1910.         case XbWDDb_NPtr: *inh = (char*)&(((XbWDDb_DbINPtr  *)TV)->inh); return(1);
  1911.         case XbWDDb_IPtr: *inh = (char*)&(((XbWDDb_DbIIPtr  *)TV)->inh); return(1);
  1912.         case XbWDDb_GPtr: *inh = (char*)&(((XbWDDb_DbIGPtr  *)TV)->inh); return(1);
  1913.         case XbWDDb_FPtr: *inh = (char*)&(((XbWDDb_DbIFPtr  *)TV)->inh); return(1);
  1914.         default    :  return(0);
  1915.         };
  1916.       };
  1917.     ii++;
  1918.     };
  1919.   return(0);
  1920.   };
  1921. /*}}}  */
  1922. /*{{{  XbWFDb_LinkDbI(     ****/
  1923. int  XbWFDb_LinkDbI(void  *(*p)[]){
  1924.   XbWDDb_DbIStr  *TSRC;
  1925.   XbWDDb_DbINPtr  *TTRG;
  1926.   XbWDDb_DbIPtr TVV;
  1927.   XbWDDb_DbIVar  *TV;
  1928.   XbWDDb_DbIVar  *TPP;
  1929.   int other_prj = 0;
  1930.   if ((int)(*p)[0] < 6) {return(1);};
  1931.   if ((int)(*p)[0] == 7) { other_prj = 1;};
  1932.   if ((TV = XbWFDb_FindGrp((char*)(*p)[4],(char*)(*p)[5]) ) == NULL) {
  1933.     return(1);
  1934.     };
  1935.   if ((TTRG = (XbWDDb_DbINPtr *)XbWFDb_VarInh(TV,0,(char*)(*p)[6],0)) == NULL) {
  1936.     return(1);
  1937.     };
  1938.   if ((TV = XbWFDb_FindGrp((char*)(*p)[1],(char*)(*p)[2]) ) == NULL) {
  1939.     return(1);
  1940.     };
  1941.   if ((TSRC = (XbWDDb_DbIStr *)XbWFDb_VarInh(TV,0,(char*)(*p)[3],0)) == NULL) {
  1942.     return(1);
  1943.     };
  1944.   if ((TTRG->tp & XbWDDb_Typ) == XbWDDb_NPtr) {
  1945.     TPP = XbWDDb_DbIPrj;
  1946.     if (other_prj){
  1947.       XbWFDb_SetPrj((char*)(*p)[7]);
  1948.       };
  1949.     TVV = XbWDDb_C_PtrToDbI(TSRC,XbWDDb_DbISys);
  1950.     XbWDDb_DbIPrj = TPP;
  1951.     ((XbWDDb_DbINPtr  *)TTRG)->inh = TVV;
  1952.     return(0);
  1953.     };
  1954.   return(1);
  1955.   };
  1956. /*}}}  */
  1957. /*{{{  XbWFDb_PrjName(     ****/
  1958. int  XbWFDb_PrjName(void  *(*p)[],int (*t)[]){
  1959.   char prjname[60];
  1960.  
  1961.   strcpy(prjname,"(default)");
  1962.   if ((int)(*p)[0] < 1 ) {return(XbWDMf_NoPara);};
  1963.   switch( (int)(*t)[1] ) {
  1964.     case XbWDMf_StrPar:
  1965.       strcpy(prjname,(char*)(XbWFTb_PckTxt((char*)(*p)[1])));
  1966.       break;
  1967.     case XbWDMf_VLPar:
  1968.       {
  1969.         XbWDDb_DbIVar  *QQ;
  1970.         char *fsp;
  1971.         QQ = (XbWDDb_DbIVar  *)(*p)[1];
  1972.         if (QQ == NULL) { return(1); };
  1973.         fsp = (char*)XbWFDb_VarInh(QQ,XbWDDb_Str,NULL,1);
  1974.         if (fsp != NULL) {
  1975.           strcpy(prjname,(char*)XbWFTb_PckTxt(fsp));
  1976.           };
  1977.         };
  1978.       break;
  1979.     };
  1980.  
  1981.   strcpy(XbWVSy_PrjName,prjname);
  1982.   return(0);
  1983.   };
  1984. /*}}}  */
  1985. /*{{{  XbWFDb_MarkPrj(     ****/
  1986. int  XbWFDb_MarkPrj(void  *(*p)[],int (*t)[]){
  1987.   char prjname[60];
  1988.   XbWDDb_DbINPtr  *TL;
  1989.  
  1990.   strcpy(prjname,"(default)");
  1991.   if ((int)(*p)[0] < 1 ) {return(XbWDMf_NoPara);};
  1992.   switch( (int)(*t)[1] ) {
  1993.     case XbWDMf_StrPar:
  1994.       strcpy(prjname,(char*)(XbWFTb_PckTxt((char*)(*p)[1])));
  1995.       break;
  1996.     };
  1997.  
  1998.   strcpy(XbWVSy_PrjName,prjname);
  1999.   printf("Creating project \"%s\"\n",prjname);
  2000.  
  2001.   if ((XbWDDb_DbIVar  *)XbWFDb_GtEOT() != (XbWDDb_DbIVar *)XbWDDb_DbISys) {
  2002.     TL = (XbWDDb_DbINPtr  *)XbWDDb_DbIPrj;
  2003.     if ((TL = (XbWDDb_DbINPtr  *)XbWFDb_FindNptr((XbWDDb_DbIVar  *)TL,"PRJ")) == 0) {
  2004.       return(1);
  2005.       };
  2006.     while (TL->inh != 0) {
  2007.       TL = (XbWDDb_DbINPtr  *)XbWFDb_CDbIToPtr( ((XbWDDb_DbINPtr  *)TL)->inh,XbWDDb_DbISys);
  2008.       if ((TL = (XbWDDb_DbINPtr  *)XbWFDb_GtPrj((char*)XbWFDb_GetStr((XbWDDb_DbIStr  *)TL))) == 0) {
  2009.         return(1);};
  2010.       if ((TL = (XbWDDb_DbINPtr  *)XbWFDb_FindNptr((XbWDDb_DbIVar  *)TL,"PRJ")) == 0) {
  2011.         return(1);};
  2012.       };
  2013.     ((XbWDDb_DbINPtr  *)TL)->inh = XbWDDb_C_PtrToDbI((XbWDDb_DbIVar  *)XbWFDb_GtEOT(),XbWDDb_DbISys);
  2014.     };
  2015.   XbWDDb_DbIPrj = (XbWDDb_DbIVar  *)XbWFDb_GtEOT();
  2016.   XbWDDb_DbIGrp = (XbWDDb_DbIStr  *)XbWFDb_GtEOT();
  2017.   return(0);
  2018.   };
  2019. /*}}}  */
  2020. /*{{{  XbWFDb_SetPrj(     ****/
  2021. int  XbWFDb_SetPrj(char *prj_name){
  2022.   XbWDDb_DbINPtr  *TL;
  2023.   TL = (XbWDDb_DbINPtr  *)XbWDDb_DbISys;
  2024.   XbWDDb_DbIPrj = (XbWDDb_DbIVar  *)XbWDDb_DbISys;
  2025.   if (strcmp((char*)XbWFDb_GetStr((XbWDDb_DbIStr  *)TL),prj_name)==0){
  2026.     XbWFTb_ClrScr();
  2027.     XbWDDb_DbIPrj = (XbWDDb_DbIVar  *)TL;
  2028.     XbWFWd_DrawAll();
  2029.     return(0);
  2030.     };
  2031.   while (1) {
  2032.     if ((TL = (XbWDDb_DbINPtr  *)XbWFDb_FindNptr((XbWDDb_DbIVar  *)TL,"PRJ")) == 0) {return(1);};
  2033.     if ( ((XbWDDb_DbINPtr  *)TL)->inh == 0){
  2034.       return(1);
  2035.       };
  2036.     TL = (XbWDDb_DbINPtr  *)XbWFDb_CDbIToPtr( ((XbWDDb_DbINPtr  *)TL)->inh,XbWDDb_DbISys);
  2037.     XbWDDb_DbIPrj = (XbWDDb_DbIVar  *)TL;
  2038.     if (strcmp((char*)XbWFDb_GetStr((XbWDDb_DbIStr  *)TL),prj_name)==0){
  2039.       XbWDDb_DbIPrj = (XbWDDb_DbIVar  *)TL;
  2040.       return(0);
  2041.       };
  2042.     };
  2043.   };
  2044. /*}}}  */
  2045. /*{{{  XbWFDb_SetProject(     ****/
  2046. int  XbWFDb_SetProject(void  *(*p)[], int (*t)[]){
  2047.   char prj_name[40] = "";
  2048.   char wdw_name[40] = "";
  2049.   if ((int)(*p)[0] < 2 ) { return(1); };
  2050.  
  2051.   switch( (int)(*t)[1] ) {
  2052.     case XbWDMf_StrPar:
  2053.       strcpy(prj_name,(char*)(XbWFTb_PckTxt((char*)(*p)[1])));
  2054.       break;
  2055.     case XbWDMf_VLPar:
  2056.       {
  2057.         XbWDDb_DbIVar  *QQ;
  2058.         char *fsp;
  2059.         QQ = (XbWDDb_DbIVar  *)(*p)[1];
  2060.         if (QQ == NULL) { return(1); };
  2061.         fsp = (char*)XbWFDb_VarInh(QQ,XbWDDb_Str,NULL,1);
  2062.         if (fsp != NULL) {
  2063.           strcpy(prj_name,(char*)XbWFTb_PckTxt(fsp));
  2064.           }
  2065.         else {
  2066.           return(2);
  2067.           };
  2068.         };
  2069.       break;
  2070.     };
  2071.   switch( (int)(*t)[2] ) {
  2072.     case XbWDMf_StrPar:
  2073.       strcpy(wdw_name,(char*)(XbWFTb_PckTxt((char*)(*p)[2])));
  2074.       break;
  2075.     case XbWDMf_VLPar:
  2076.       {
  2077.         XbWDDb_DbIVar  *QQ;
  2078.         char *fsp;
  2079.         QQ = (XbWDDb_DbIVar  *)(*p)[2];
  2080.         if (QQ == NULL) { return(1); };
  2081.         fsp = (char*)XbWFDb_VarInh(QQ,XbWDDb_Str,NULL,1);
  2082.         if (fsp != NULL) {
  2083.           strcpy(wdw_name,(char*)XbWFTb_PckTxt(fsp));
  2084.           }
  2085.         else {
  2086.           return(2);
  2087.           };
  2088.         };
  2089.       break;
  2090.     };
  2091.   if (!XbWFDb_SetPrj(prj_name)){
  2092.     int count;
  2093.     XbWFTb_ClrScr();
  2094.     XbWFWd_GetList();
  2095.     for (count = 1;count <= XbWDWd_MaxWdw;count++) {
  2096.       if (XbWFWd_GetPara(count,&XbWVWd_W) != 0) {
  2097.         if (wdw_name != NULL){
  2098.           if (XbWFTb_CmpStr((char*)XbWVWd_W.nm,wdw_name)==0){
  2099.             XbWFWd_DrawAll();
  2100.             return(0);
  2101.             };
  2102.           };
  2103.         };
  2104.       };
  2105.     };
  2106.   return(1);
  2107.   };
  2108. /*}}}  */
  2109. /*{{{  XbWFDb_MarlGrp(     ****/
  2110. int  XbWFDb_MarlGrp(void  *(*p)[]){
  2111.   XbWDDb_DbINPtr  *TL;
  2112.   int mrk_key=0;
  2113.   int mrk_obj=0;
  2114.   char *lname;
  2115.  
  2116.   if ((int)(*p)[0] < 1) {return(1);};
  2117.  
  2118.   lname = (char*)(*p)[1];
  2119.  
  2120.   if (XbWFTb_CmpStr(lname,"PRJ") == 0) {
  2121.     XbWVDb_AktDKey = NULL;
  2122.     XbWVDb_AktDObj = NULL;
  2123.  
  2124.     XbWDDb_DbIGrp = (XbWDDb_DbIStr  *)XbWFDb_GtEOT();
  2125.     return(0);
  2126.     };
  2127.  
  2128.   if ((XbWDDb_DbIVar  *)XbWFDb_GtEOT() == (XbWDDb_DbIVar *)XbWDDb_DbISys) {
  2129.     XbWDDb_DbIGrp = (XbWDDb_DbIStr  *)XbWFDb_GtEOT();
  2130.     return(0);
  2131.     };
  2132.  
  2133.   if (XbWFTb_CmpStr(lname,"OBJ") == 0) {
  2134.     mrk_obj =1;
  2135.     if (XbWVDb_AktDObj != NULL) {
  2136.       TL = (XbWDDb_DbINPtr  *)XbWVDb_AktDObj;
  2137.       goto ITMmarkGRPweiter;
  2138.       };
  2139.     };
  2140.   if (XbWFTb_CmpStr(lname,"KEY") == 0) {
  2141.     mrk_key=1;
  2142.     if (XbWVDb_AktDKey != NULL) {
  2143.       TL = (XbWDDb_DbINPtr  *)XbWVDb_AktDKey;
  2144.       goto ITMmarkGRPweiter;
  2145.       };
  2146.     };
  2147.  
  2148.   TL = (XbWDDb_DbINPtr  *)XbWDDb_DbIPrj;
  2149.   if ((TL = (XbWDDb_DbINPtr  *)XbWFDb_FindNptr((XbWDDb_DbIVar  *)TL,lname)) == 0) {return(1);};
  2150.  
  2151.   ITMmarkGRPweiter:;
  2152.   while (TL->inh != 0) {
  2153.     TL = (XbWDDb_DbINPtr  *)XbWFDb_CDbIToPtr( ((XbWDDb_DbINPtr  *)TL)->inh,XbWDDb_DbISys);
  2154.     if ((TL = (XbWDDb_DbINPtr  *)XbWFDb_FindNptr((XbWDDb_DbIVar  *)TL,lname)) == 0) {return(1);};
  2155.     };
  2156.   if (mrk_key) {
  2157.     XbWVDb_AktDKey = (XbWDDb_DbIVar  *)TL;
  2158.     };
  2159.   if (mrk_obj) {
  2160.     XbWVDb_AktDObj = (XbWDDb_DbIVar  *)TL;
  2161.     };
  2162.   ((XbWDDb_DbINPtr  *)TL)->inh = XbWDDb_C_PtrToDbI((XbWDDb_DbIVar  *)XbWFDb_GtEOT(),XbWDDb_DbISys);
  2163.   XbWDDb_DbIGrp = (XbWDDb_DbIStr  *)XbWFDb_GtEOT();
  2164.   return(0);
  2165.   };
  2166. /*}}}  */
  2167. /*{{{  XbWFDb_OutLine(     ****/
  2168. void  XbWFDb_OutLine(FILE *fp) {
  2169.   fprintf(fp,    "----------------------------------------------------------------\n");
  2170.   };
  2171. /*}}}  */
  2172. /*{{{  XbWFDb_DbgSys(      ****/
  2173. int  XbWFDb_DbgSys(void  *(*p)[]){
  2174.   char *fname;
  2175.   FILE *fp;
  2176.   int cursormrk;
  2177.   void  *oldcursor;
  2178.   XbWDDb_DbIVar  *END;
  2179.   XbWDDb_DbIVar  *AP;
  2180.   XbWDDb_DbIStr  *TS;
  2181.   long oc,wc,ic,sc,pc,dc,mc,
  2182.   is,ss,ds,ps,as,ls,ins,dns,sns,pns,vc;
  2183.  
  2184.   oc = wc = ic = sc = pc = mc = dc =  0;
  2185.   is = ss = ds = ps = ls = ins = dns = sns = pns = vc = 0;
  2186.   if ((int)(*p)[0] < 1 ) {return(1);};
  2187.   fname = (char *)(*p)[1];
  2188.   XbWVDb_PrjSize = 0;
  2189.  
  2190.  
  2191.   if ((fp = XbWSSy_fopen(fname,"wt")) == NULL) {
  2192.     return(1);
  2193.     };
  2194.  
  2195.   cursormrk = XbWVMs_CSet;
  2196.   oldcursor = XbWSMs_SetClockCursor();
  2197.   XbWFGr_CurON();
  2198.  
  2199.   {
  2200.     char pstr[200];
  2201.     sprintf(pstr,"Dumping database to %s",fname);
  2202.     XbWFTb_Message(pstr);
  2203.     };
  2204.  
  2205.   fprintf(fp,"/* * * Xb Dialog Interface Script * * */\n");
  2206.   #ifdef TEST
  2207.     puts("Xb ...");
  2208.     #endif
  2209.   END = (XbWDDb_DbIVar  *)XbWFDb_GtEOT();
  2210.   AP = (XbWDDb_DbIVar  *)XbWDDb_DbISys;
  2211.   XbWVDb_PrjSize =0;
  2212.   XbWDDb_DbIPrj = (XbWDDb_DbIVar  *)XbWDDb_DbISys;
  2213.   while (AP < END) {
  2214.     XbWFDb_DbgVar(AP,fp);
  2215.     switch(AP->tp & XbWDDb_Typ){
  2216.       case XbWDDb_Int :
  2217.                    ic++;
  2218.                    as = XbWFDb_GetSiz(AP);
  2219.                    XbWVDb_PrjSize += as;
  2220.                    is += as;
  2221.                    ins += (AP->tp & XbWDDb_NLen);
  2222.                    vc++;
  2223.                    break;
  2224.       case XbWDDb_Dbl :
  2225.                    dc++;
  2226.                    as = XbWFDb_GetSiz(AP);
  2227.                    XbWVDb_PrjSize += as;
  2228.                    ds += as;
  2229.                    dns += (AP->tp & XbWDDb_NLen);
  2230.                    vc++;
  2231.                    break;
  2232.       case XbWDDb_NPtr:
  2233.                    pc++;
  2234.                    as = XbWFDb_GetSiz(AP);
  2235.                    XbWVDb_PrjSize += as;
  2236.                    ps += as;
  2237.                    pns += (AP->tp & XbWDDb_NLen);
  2238.                    vc++;
  2239.                    break;
  2240.       case XbWDDb_IPtr:
  2241.                    pc++;
  2242.                    as = XbWFDb_GetSiz(AP);
  2243.                    XbWVDb_PrjSize += as;
  2244.                    ps += as;
  2245.                    pns += (AP->tp & XbWDDb_NLen);
  2246.                    vc++;
  2247.                    break;
  2248.       case XbWDDb_GPtr:
  2249.                    pc++;
  2250.                    as = XbWFDb_GetSiz(AP);
  2251.                    XbWVDb_PrjSize += as;
  2252.                    ps += as;
  2253.                    fprintf(fp,"\n");
  2254.                    XbWFDb_OutLine(fp);
  2255.                    pns += (AP->tp & XbWDDb_NLen);
  2256.                    vc++;
  2257.                    break;
  2258.       case XbWDDb_FPtr:
  2259.                    pc++;
  2260.                    fprintf(fp,"\n");
  2261.                    XbWFDb_OutLine(fp);
  2262.                    as = XbWFDb_GetSiz(AP);
  2263.                    XbWVDb_PrjSize += as;
  2264.                    ps += as;
  2265.                    pns += (AP->tp & XbWDDb_NLen);
  2266.                    vc++;
  2267.                    break;
  2268.       case XbWDDb_Str :TS  = (XbWDDb_DbIStr  *)AP;
  2269.                    sc++;
  2270.                    if (XbWFTb_CmpStr((char*)XbWFDb_GetNam((XbWDDb_DbIVar  *)TS),"OBJ") == 0){
  2271.                      oc++;
  2272.                      };
  2273.                    if (XbWFTb_CmpStr((char*)XbWFDb_GetNam((XbWDDb_DbIVar  *)TS),"WDW") == 0){
  2274.                      wc++;
  2275.                      };
  2276.                    if (XbWFTb_CmpStr((char*)XbWFDb_GetNam((XbWDDb_DbIVar  *)TS),"MFX") == 0){
  2277.                      mc++;
  2278.                      };
  2279.                    ls += 2*TS->len;
  2280.                    as = XbWFDb_GetSiz(AP);
  2281.                    XbWVDb_PrjSize += as;
  2282.                    ss += as;
  2283.                    sns += (AP->tp & XbWDDb_NLen);
  2284.                    vc++;
  2285.                    break;
  2286.       };
  2287.     AP = XbWFDb_CDbIToPtr(XbWDDb_C_PtrToDbI(AP,XbWDDb_DbISys)+XbWFDb_GetSiz(AP),XbWDDb_DbISys);
  2288.     };
  2289.  
  2290.   fprintf(fp,"\n\n");
  2291.   XbWFDb_OutLine(fp);
  2292.   fprintf(fp,  "\nStatistics\n\n");
  2293.   fprintf(fp,"\n\nnumber of  windows   : %5ld\n",wc);
  2294.   fprintf(fp,    "number of  MFX-Groups: %5ld\n",mc);
  2295.   fprintf(fp,    "number of  objects   : %5ld\n",oc);
  2296.   fprintf(fp,    "number of  variables : %5ld\n",vc);
  2297.   XbWFDb_OutLine(fp);
  2298.   if (ic > 0) {
  2299.     fprintf(fp,    "           integers  : %5ld (%6ld Byte); %4.1f Byte/int\n",ic,is,(double)(((double)is)/ic));
  2300.     };
  2301.   if (sc > 0) {
  2302.     fprintf(fp,    "           strings   : %5ld (%6ld Byte); %4.1f Byte/str\n",sc,ss,(double)(((double)ss)/sc));
  2303.     };
  2304.   if (pc > 0) {
  2305.     fprintf(fp,    "           pointers  : %5ld (%6ld Byte); %4.1f Byte/ptr\n",pc,ps,(double)(((double)ps)/pc));
  2306.     };
  2307.   if (dc > 0) {
  2308.     fprintf(fp,    "           doubles   : %5ld (%6ld Byte); %4.1f Byte/dbl\n",dc,ds,(double)(((double)ds)/dc));
  2309.     };
  2310.   XbWFDb_OutLine(fp);
  2311.   fprintf(fp,    "netto size integers  :        %6ld Byte; %4.1f Byte/int\n",(long)ic*sizeof(int),(double)sizeof(int));
  2312.   if (sc > 0) {
  2313.     fprintf(fp,    "           strings   :        %6ld Byte; %4.1f Byte/str\n",ls,(double)(((double)ls)/sc));
  2314.     };
  2315.   fprintf(fp,    "           pointers  :        %6ld Byte; %4.1f Byte/ptr\n",(long)pc*sizeof(XbWDDb_DbIPtr),(double)sizeof(XbWDDb_DbIPtr));
  2316.   fprintf(fp,    "           doubles   :        %6ld Byte; %4.1f Byte/dbl\n",(long)dc*sizeof(double),(double)sizeof(double));
  2317.   XbWFDb_OutLine(fp);
  2318.   if (ic > 0){
  2319.     fprintf(fp,    "names size integers  :        %6ld Byte; %4.1f Byte/int\n",ins,(double)(((double)ins)/ic));
  2320.     };
  2321.   if (sc > 0) {
  2322.     fprintf(fp,    "           strings   :        %6ld Byte; %4.1f Byte/str\n",sns,(double)(((double)sns)/sc));
  2323.     };
  2324.   if (pc > 0) {
  2325.     fprintf(fp,    "           pointers  :        %6ld Byte; %4.1f Byte/ptr\n",pns,(double)(((double)pns)/pc));
  2326.     };
  2327.   if (dc > 0) {
  2328.     fprintf(fp,    "           doubles   :        %6ld Byte; %4.1f Byte/dbl\n",dns,(double)(((double)dns)/dc));
  2329.     };
  2330.   XbWFDb_OutLine(fp);
  2331.   if (ic > 0) {
  2332.     fprintf(fp,    "misc. size integers  :        %6ld Byte; %4.1f Byte/int\n",is-ins-(long)ic*sizeof(int),(double)(is-ins-(long)ic*sizeof(int))/ic);
  2333.     };
  2334.   if (sc > 0) {
  2335.     fprintf(fp,    "           strings   :        %6ld Byte; %4.1f Byte/str\n",ss-sns-ls,(double)(ss-sns-ls)/sc);
  2336.     };
  2337.   if (pc > 0) {
  2338.     fprintf(fp,    "           pointers  :        %6ld Byte; %4.1f Byte/ptr\n",ps-pns-(long)pc*sizeof(XbWDDb_DbIPtr),(double)(ps-pns-(long)pc*sizeof(XbWDDb_DbIPtr))/pc);
  2339.     };
  2340.   if (dc > 0) {
  2341.     fprintf(fp,    "           doubles   :        %6ld Byte; %4.1f Byte/dbl\n",ds-dns-(long)dc*sizeof(double),(double)(ds-dns-(long)dc*sizeof(double))/dc);
  2342.     };
  2343.   XbWFDb_OutLine(fp);
  2344.   {
  2345.     long akts;
  2346.     double perc;
  2347.  
  2348.     akts = (long)ic*sizeof(int)+ls+dc*sizeof(double);
  2349.     if (XbWVDb_PrjSize > 0) {
  2350.       perc = 100.0*akts/XbWVDb_PrjSize;
  2351.       }
  2352.     else {
  2353.       perc = 0;
  2354.       };
  2355.     fprintf(fp,"\n\nnetto data size      : %6ld Byte (%4.1f%%)\n",akts,perc);
  2356.  
  2357.     akts = (long)ic*sizeof(int)+ls+dc*sizeof(double)+pc*sizeof(XbWDDb_DbIPtr);
  2358.     perc = 100.0*akts/XbWVDb_PrjSize;
  2359.     fprintf(fp,"\n\nbrutto (incl pointer): %6ld Byte (%4.1f%%)\n",akts,perc);
  2360.  
  2361.     akts = XbWVDb_PrjSize-akts;
  2362.     perc = 100.0*akts/XbWVDb_PrjSize;
  2363.     fprintf(fp,"\n\noverhead             : %6ld Byte (%4.1f%%)\n",akts,perc);
  2364.     fprintf(fp,"\n\nproject size         : %6ld Byte.\n",XbWVDb_PrjSize);
  2365.     fprintf(fp,"\n\n----------------------------------------------------------------\n");
  2366.     };
  2367.   fclose(fp);
  2368.   XbWFTb_Message(".");
  2369.   if (!cursormrk) {
  2370.     XbWFGr_CurOFF();
  2371.     };
  2372.   XbWSMs_SetLastCursor(oldcursor);
  2373.   return(0);
  2374.   };
  2375.  
  2376. /*}}}  */
  2377. /*{{{  XbWFDb_WrTable(     ***    Datenbank binaer schreiben*/
  2378. int  XbWFDb_WrTable(void  *(*p)[],int (*t)[]){
  2379.   XbWDDb_Header th;
  2380.   char s_dir[60];
  2381.   void  *mrk;
  2382.   void  *oldcursor;
  2383.   char name[60];
  2384.   int write_complete=0;
  2385.   FILE *fp;
  2386.   if ((int)(*p)[0] < 1 ) {return(XbWDMf_NoPara);};
  2387.   if ((int)(*p)[0] >= 2 ) {
  2388.     switch( (int)(*t)[2] ) {
  2389.       case XbWDMf_StrPar:
  2390.         strcpy(s_dir,(char*)(XbWFTb_PckTxt((char*)(*p)[2])));
  2391.         break;
  2392.       case XbWDMf_VLPar:
  2393.         {
  2394.           XbWDDb_DbIVar  *QQ;
  2395.           char *fsp;
  2396.           QQ = (XbWDDb_DbIVar  *)(*p)[2];
  2397.           if (QQ == NULL) { return(1); };
  2398.           fsp = (char*)XbWFDb_VarInh(QQ,XbWDDb_Str,NULL,1);
  2399.           if (fsp != NULL) {
  2400.             strcpy(s_dir,(char*)XbWFTb_PckTxt(fsp));
  2401.             };
  2402.           };
  2403.         break;
  2404.       };
  2405.     }
  2406.   else {
  2407.     strcpy(s_dir,"");
  2408.     };
  2409.   switch( (int)(*t)[1] ) {
  2410.     case XbWDMf_StrPar:
  2411.       strcpy(name,(char*)(XbWFTb_PckTxt((char*)(*p)[1])));
  2412.       break;
  2413.     case XbWDMf_VLPar:
  2414.       {
  2415.         XbWDDb_DbIVar  *QQ;
  2416.         char *fsp;
  2417.         QQ = (XbWDDb_DbIVar  *)(*p)[1];
  2418.         if (QQ == NULL) { return(1); };
  2419.         fsp = (char*)XbWFDb_VarInh(QQ,XbWDDb_Str,NULL,1);
  2420.         if (fsp == NULL) { return(1); };
  2421.         strcpy(name,(char*)XbWFTb_PckTxt(fsp));
  2422.         };
  2423.       break;
  2424.     };
  2425.   if ((int)(*p)[0] >= 3 ) {
  2426.     switch( (int)(*t)[3] ) {
  2427.       case XbWDMf_IntPar:
  2428.         write_complete = (int)(*p)[3];
  2429.         break;
  2430.       case XbWDMf_VLPar:
  2431.         {
  2432.           XbWDDb_DbIVar  *QQ;
  2433.           QQ = (XbWDDb_DbIVar  *)(*p)[3];
  2434.           if (QQ == NULL) { return(1); };
  2435.           write_complete = (int)XbWFDb_GetNum(QQ,NULL,1);
  2436.           };
  2437.         break;
  2438.       };
  2439.     }
  2440.   if (name[0] == '*'){
  2441.     fp = XbWSSy_fopen("\\xw\\x\\sys\\RESUME.PRJ","wb");
  2442.     }
  2443.   else {
  2444.     strcat(s_dir,name);
  2445.     if (strchr(s_dir,'.') == NULL){
  2446.       strcat(s_dir,".PRJ");
  2447.       };
  2448.     fp = XbWSSy_fopen(s_dir,"wb");
  2449.     };
  2450.   if (fp != NULL) {
  2451.     strcpy(th.name,"XbWindows Project (c) 1992 HHM");
  2452.     strcpy(th.reserviert,"HHM                                                 ");
  2453.  
  2454.     th.tab_start = 0;
  2455.  
  2456.     th.akt_projekt = (long)XbWDDb_C_PtrToDbI(XbWDDb_DbIPrj,XbWVDb_DbkStrt);
  2457.     mrk = (void  *)XbWDDb_DbIPrj;
  2458.     XbWDDb_DbIPrj = (XbWDDb_DbIVar  *)XbWVDb_DbkStrt;
  2459.  
  2460.     th.akt_group = (long)XbWDDb_C_PtrToDbI(XbWDDb_DbIGrp,XbWVDb_DbkStrt);;
  2461.     th.akt_sys   = (long)XbWDDb_C_PtrToDbI(XbWDDb_DbISys,XbWVDb_DbkStrt);;
  2462.     th.akt_ende  = (long)XbWDDb_C_PtrToDbI(XbWFDb_GtEOT(),XbWVDb_DbkStrt);
  2463.     if (XbWVWd_W.nm != NULL){
  2464.       strcpy(th.akt_wdw,(char*)XbWVWd_W.nm);
  2465.       }
  2466.     else {
  2467.       strcpy(th.akt_wdw,"!!");
  2468.       };
  2469.     if (!write_complete){
  2470.       th.tab_size = (long)XbWDDb_C_PtrToDbI(XbWFDb_GtEOT(),XbWVDb_DbkStrt)+ 10000;
  2471.       }
  2472.     else {
  2473.       th.tab_size = XbWVDb_DbkStrt->ITM_MAX;
  2474.       };
  2475.  
  2476.     XbWFTb_Message("Writing Database...");
  2477.  
  2478.     oldcursor = XbWSMs_SetClockCursor();
  2479.     fwrite((void*)&th,sizeof(th),1,fp);
  2480.     fwrite((void*)XbWVDb_DbkStrt,(int)(th.tab_size*1.0/1024)+1,1024,fp);
  2481.     XbWSMs_SetLastCursor(oldcursor);
  2482.     XbWDDb_DbIPrj = (XbWDDb_DbIVar  *)mrk;
  2483.     fclose(fp);
  2484.     XbWFTb_Message(".");
  2485.     return(0);
  2486.     };
  2487.   return(1);
  2488.   };
  2489.  
  2490. /*}}}  */
  2491. /*{{{  XbWFDb_RdTable(     ***    Datenbank binaer lesen*/
  2492. int  XbWFDb_RdTable(void  *(*p)[], int (*t)[]){
  2493.   XbWDDb_Header th;
  2494.   char name[60];
  2495.   char s_dir[60];
  2496.   void  *oldcursor;
  2497.   FILE *fp;
  2498.   int draw_windows;
  2499.   int read_kbytes=0;
  2500.   if ((int)(*p)[0] < 1 ) {return(XbWDMf_NoPara);};
  2501.   if ((int)(*p)[0] >= 2 ) {
  2502.     switch( (int)(*t)[2] ) {
  2503.       case XbWDMf_StrPar:
  2504.         strcpy(s_dir,(char*)(XbWFTb_PckTxt((char*)(*p)[2])));
  2505.         break;
  2506.       case XbWDMf_VLPar:
  2507.         {
  2508.           XbWDDb_DbIVar  *QQ;
  2509.           char *fsp;
  2510.           QQ = (XbWDDb_DbIVar  *)(*p)[2];
  2511.           if (QQ == NULL) { return(1); };
  2512.           fsp = (char*)XbWFDb_VarInh(QQ,XbWDDb_Str,NULL,1);
  2513.           if (fsp != NULL) {
  2514.             strcpy(s_dir,(char*)XbWFTb_PckTxt(fsp));
  2515.             };
  2516.           };
  2517.         break;
  2518.       default: return(1);
  2519.       };
  2520.     }
  2521.   else {
  2522.     strcpy(s_dir,"");
  2523.     };
  2524.   switch( (int)(*t)[1] ) {
  2525.     case XbWDMf_StrPar:
  2526.       strcpy(name,(char*)(XbWFTb_PckTxt((char*)(*p)[1])));
  2527.       break;
  2528.     case XbWDMf_VLPar:
  2529.       {
  2530.         XbWDDb_DbIVar  *QQ;
  2531.         char *fsp;
  2532.         QQ = (XbWDDb_DbIVar  *)(*p)[1];
  2533.         if (QQ == NULL) { return(1); };
  2534.         fsp = (char*)XbWFDb_VarInh(QQ,XbWDDb_Str,NULL,1);
  2535.         if (fsp == NULL) { return(1); };
  2536.         strcpy(name,(char*)XbWFTb_PckTxt(fsp));
  2537.         };
  2538.       break;
  2539.     default: return(1);
  2540.     };
  2541.  
  2542.   draw_windows = 1;
  2543.   if ((int)(*p)[0] >= 3 ) {
  2544.     switch( (int)(*t)[3] ) {
  2545.       case XbWDMf_VLPar:
  2546.         {
  2547.           XbWDDb_DbIVar  *QQ;
  2548.           QQ = (XbWDDb_DbIVar  *)(*p)[3];
  2549.           if (QQ == NULL) { return(1); };
  2550.           draw_windows = XbWFDb_GetNum(QQ,NULL,1);
  2551.           };
  2552.         break;
  2553.       case XbWDMf_IntPar:
  2554.       case XbWDMf_VPPar:
  2555.         draw_windows = (int)(*p)[3];
  2556.         break;
  2557.       default: return(1);
  2558.       };
  2559.     };
  2560.   if ((int)(*p)[0] >= 4 ) {
  2561.     switch( (int)(*t)[4] ) {
  2562.       case XbWDMf_IntPar:
  2563.         read_kbytes = (int)(*p)[4];
  2564.         break;
  2565.       case XbWDMf_VLPar:
  2566.         {
  2567.           XbWDDb_DbIVar  *QQ;
  2568.           QQ = (XbWDDb_DbIVar  *)(*p)[4];
  2569.           if (QQ == NULL) { return(1); };
  2570.           read_kbytes = (int)XbWFDb_GetNum(QQ,NULL,1);
  2571.           };
  2572.         break;
  2573.       };
  2574.     }
  2575.   if (name[0] == '*'){
  2576.     fp = XbWSSy_fopen("/xw/x/sys/resume.prj","rb");
  2577.     }
  2578.   else {
  2579.     strcat(s_dir,name);
  2580.     if (strchr(s_dir,'.') == NULL) {
  2581.       strcat(s_dir,".PRJ");
  2582.       };
  2583.     fp = XbWSSy_fopen(s_dir,"rb");
  2584.     };
  2585.  
  2586.   if (XbWVDb_DbkStat == 1) {
  2587.     XbWFDb_CloseSys();
  2588.     };
  2589.   if (XbWVDb_DbkStat == 2) {
  2590.     struct stat statbuf;
  2591.     if (fstat(XbWVDb_DbkFile,&statbuf)<0){
  2592.       printf("could not fstat() active database file.\n");
  2593.       exit(1);
  2594.       };
  2595.     munmap((caddr_t)XbWVDb_DbkStrtMem,statbuf.st_size);
  2596.     close(XbWVDb_DbkFile);
  2597.     };
  2598.  
  2599.  
  2600.   if (fp != NULL) {
  2601.     fread((void*)&th,sizeof(th),1,fp);
  2602.     if (XbWVDb_DbkStat == 1) {
  2603.       XbWFDb_CloseSys();
  2604.       };
  2605.     XbWVDb_DbkStat = 1;
  2606.  
  2607.     if (!read_kbytes){
  2608.       XbWVDb_DbkStrt = (XbWDDb_Sys  *)(XbWSSy_AlocMem((th.tab_size/100)+20,100));
  2609.       }
  2610.     else {
  2611.       XbWVDb_DbkStrt = (XbWDDb_Sys  *)(XbWSSy_AlocMem(read_kbytes+2,1024));
  2612.       };
  2613.     if (XbWVDb_DbkStrt == NULL) {
  2614.       #ifdef TEST
  2615.         puts("HEAP ERROR!!");
  2616.       #else
  2617.         XbWSPu_Alarm("HEAP ERROR!");
  2618.         #endif
  2619.       exit(1);
  2620.       };
  2621.     XbWVDb_DbkStrt->ITM_MAX     = (XbWDDb_DbIPtr)(1.0*th.tab_size);
  2622.     XbWVDb_DbkStrt->T_ITM_END   = (void  *)XbWDDb_Dbk;
  2623.     XbWFDb_Add(sizeof(XbWDDb_Sys));
  2624.     XbWVDb_DbkStrt->T_ITM_PRJ = (XbWDDb_DbIVar  *)XbWFDb_GtEOT();
  2625.     XbWVDb_DbkStrt->T_ITM_SYS = (XbWDDb_DbIStr  *)XbWFDb_GtEOT();
  2626.     XbWVDb_DbkStrt->T_ITM_GRP = (XbWDDb_DbIStr  *)XbWFDb_GtEOT();
  2627.     XbWFTb_Message("Reading Database...");
  2628.     oldcursor = XbWSMs_SetClockCursor();
  2629.     fread((void *)XbWVDb_DbkStrt,(size_t)(1.0*th.tab_size/100)+1,100,fp);
  2630.     XbWSMs_SetLastCursor(oldcursor);
  2631.     fclose(fp);
  2632.     XbWVDb_DbkStrt->ITM_MAX = (long)th.tab_size;
  2633.     XbWVDb_DbkStrt->T_ITM_END = (XbWDDb_DbIVar *)((char *)XbWVDb_DbkStrt+(long)th.akt_ende);
  2634.     XbWVDb_DbkStrt->T_ITM_PRJ = (XbWDDb_DbIVar *)((char *)XbWVDb_DbkStrt+(long)th.akt_projekt);
  2635.     XbWVDb_DbkStrt->T_ITM_GRP = (XbWDDb_DbIStr *)((char *)XbWVDb_DbkStrt+(long)th.akt_group);
  2636.     XbWVDb_DbkStrt->T_ITM_SYS = (XbWDDb_DbIStr *)((char *)XbWVDb_DbkStrt+(long)th.akt_sys);
  2637.     XbWFTb_Message(".");
  2638.     if (draw_windows) {
  2639.       XbWFWd_BackGr();
  2640.       if (th.akt_wdw[0] != '!'){
  2641.         XbWFWd_SwitchTo(th.akt_wdw,0);
  2642.         };
  2643.       XbWFWd_DrawAll();
  2644.       };
  2645.     return(0);
  2646.     };
  2647.   return(1);
  2648.   };
  2649. /*}}}  */
  2650.  
  2651. /*{{{  XbWFDb_CloseSys(    ***    Datenbank loeschen*/
  2652. int  XbWFDb_CloseSys(void){
  2653.   if (XbWVDb_DbkStat == 1) {
  2654.     XbWVDb_DbkStat = 0;
  2655.     XbWSSy_FreeMem((void*)XbWVDb_DbkStrt);
  2656.     XbWVDb_DbkStrt = NULL;
  2657.     return(0);
  2658.     };
  2659.   #ifdef TEST
  2660.     puts("NO TABLE UN-ALLOCATED");
  2661.   #else
  2662.     XbWSPu_Alarm("NO TABLE UN-ALLOCATED");
  2663.     #endif
  2664.   return(1);
  2665.   };
  2666. /*}}}  */
  2667. /*{{{  XbWFDb_CreaSys(     ***    ALT!! (Speicher reservieren fuer Datenbank)*/
  2668. int  XbWFDb_CreaSys(void  *(*p)[]){
  2669.   XbWDDb_DbIPtr size;
  2670.   if ((int)(*p)[0] < 1 ) {return(XbWDMf_NoPara);};
  2671.   size = (1.0*((int)((*p)[1])));
  2672.   if (XbWVDb_DbkStat == 1) {
  2673.     XbWFDb_CloseSys();
  2674.     };
  2675.   if (XbWVDb_DbkStat == 2) {
  2676.     struct stat statbuf;
  2677.     if (fstat(XbWVDb_DbkFile,&statbuf)<0){
  2678.       printf("could not fstat() active database file.\n");
  2679.       exit(1);
  2680.       };
  2681.     munmap((caddr_t)XbWVDb_DbkStrtMem,statbuf.st_size);
  2682.     close(XbWVDb_DbkFile);
  2683.     };
  2684.  
  2685.   XbWVDb_DbkStat = 1;
  2686.   XbWVDb_AkDbkEl = NULL;
  2687.   XbWVDb_ActGrp1 = NULL;
  2688.   XbWVDb_AktDObj = NULL;
  2689.   XbWVDb_AktDKey = NULL;
  2690.   XbWVDb_DbkStrt = (XbWDDb_Sys  *)(XbWSSy_AlocMem(size,1024));
  2691.   if (XbWVDb_DbkStrt == NULL) {
  2692.     #ifdef TEST
  2693.       puts("HEAP ERROR!!");
  2694.     #else
  2695.       XbWSPu_Alarm("HEAP ERROR!");
  2696.       #endif
  2697.     exit(1);
  2698.     };
  2699.   XbWVDb_DbkStrt->ITM_MAX     = (XbWDDb_DbIPtr)(1.0*size*1024);
  2700.   XbWVDb_DbkStrt->T_ITM_END   = (void  *)XbWVDb_DbkStrt;
  2701.   XbWVDb_DbkStrt->T_ITM_END =
  2702.     (void *)((char *)(XbWVDb_DbkStrt->T_ITM_END)+(long)sizeof(XbWDDb_Sys));
  2703.   XbWVDb_DbkStrt->T_ITM_PRJ = (XbWDDb_DbIVar  *)XbWFDb_GtEOT();
  2704.   XbWVDb_DbkStrt->T_ITM_SYS = (XbWDDb_DbIStr  *)XbWFDb_GtEOT();
  2705.   XbWVDb_DbkStrt->T_ITM_GRP = (XbWDDb_DbIStr  *)XbWFDb_GtEOT();
  2706.   return(0);
  2707.   };
  2708. /*}}}  */
  2709. /*{{{  XbWFDb_OpenSys(     ***    NEU!! Datenbank schnell r/w oeffen*/
  2710. int  XbWFDb_OpenSys(void  *(*p)[], int (*t)[]){
  2711.   XbWDDb_DbIPtr size=0;
  2712.   char filename[100];
  2713.   XbWDDb_Header th;
  2714.   struct stat statbuf;
  2715.  
  2716.   if (XbWVDb_DbkStat == 1) {
  2717.     XbWFDb_CloseSys();
  2718.     };
  2719.  
  2720.   if ((int)(*p)[0] < 1 ) {return(XbWDMf_NoPara);};
  2721.     switch( (int)(*t)[1] ) {
  2722.     /*{{{  */
  2723.       case XbWDMf_StrPar:
  2724.         /*{{{  */
  2725.         strcpy(filename,(char*)(XbWFTb_PckTxt((char*)(*p)[1])));
  2726.         break;
  2727.         /*}}}  */
  2728.       case XbWDMf_VLPar:
  2729.         /*{{{  */
  2730.         {
  2731.           XbWDDb_DbIVar  *QQ;
  2732.           char *fsp;
  2733.           QQ = (XbWDDb_DbIVar  *)(*p)[1];
  2734.           if (QQ == NULL) { return(1); };
  2735.           fsp = (char*)XbWFDb_VarInh(QQ,XbWDDb_Str,NULL,1);
  2736.           if (fsp != NULL) {
  2737.             strcpy(filename,(char*)XbWFTb_PckTxt(fsp));
  2738.             };
  2739.           };
  2740.         break;
  2741.         /*}}}  */
  2742.       };
  2743.     /*}}}  */
  2744.   if ((int)(*p)[0] > 1 ) {
  2745.     switch( (int)(*t)[2] ) {
  2746.     /*{{{  */
  2747.       case XbWDMf_IntPar:
  2748.         /*{{{  */
  2749.         size = (1.0*((int)((*p)[2])));
  2750.         break;
  2751.         /*}}}  */
  2752.       };
  2753.     /*}}}  */
  2754.     };
  2755.   XbWVDb_DbkStat = 2;
  2756.   XbWVDb_AkDbkEl = NULL;
  2757.   XbWVDb_ActGrp1 = NULL;
  2758.   XbWVDb_AktDObj = NULL;
  2759.   XbWVDb_AktDKey = NULL;
  2760.  
  2761.   XbWVDb_DbkFile = open(filename,O_RDWR);
  2762.   if (XbWVDb_DbkFile<0){
  2763.     printf("Could not open database %s!!\n",filename);
  2764.     exit(1);
  2765.     };
  2766.   if (fstat(XbWVDb_DbkFile,&statbuf)<0){
  2767.     printf("could not fstat() file %s\n",filename);
  2768.     exit(1);
  2769.     };
  2770.  
  2771.   read(XbWVDb_DbkFile,&th,sizeof(th));
  2772.  
  2773.   XbWVDb_DbkStrtMem = (XbWDDb_Sys  *)mmap(0,statbuf.st_size,
  2774.                                            PROT_READ|PROT_WRITE,
  2775.                                            MAP_FILE|MAP_PRIVATE,
  2776.                                            XbWVDb_DbkFile,
  2777.                                            0 /* offset in pagesize!*/
  2778.                                            );
  2779.   if ((int)XbWVDb_DbkStrtMem==-1){
  2780.     printf("Errno %d; Could not memmap() database %s!!\n",errno,filename);
  2781.     exit(1);
  2782.     };
  2783.  
  2784.   XbWVDb_DbkStrt =  (XbWDDb_Sys  *)((char*)XbWVDb_DbkStrtMem+sizeof(XbWDDb_Header));
  2785.  
  2786.   XbWVDb_DbkStrt->ITM_MAX = (long)th.tab_size;
  2787.   XbWVDb_DbkStrt->T_ITM_END = (XbWDDb_DbIVar *)((char *)XbWVDb_DbkStrt+(long)th.akt_ende);
  2788.   XbWVDb_DbkStrt->T_ITM_PRJ = (XbWDDb_DbIVar *)((char *)XbWVDb_DbkStrt+(long)th.akt_projekt);
  2789.   XbWVDb_DbkStrt->T_ITM_GRP = (XbWDDb_DbIStr *)((char *)XbWVDb_DbkStrt+(long)th.akt_group);
  2790.   XbWVDb_DbkStrt->T_ITM_SYS = (XbWDDb_DbIStr *)((char *)XbWVDb_DbkStrt+(long)th.akt_sys);
  2791.   XbWFTb_Message(".");
  2792.  
  2793.   XbWFWd_BackGr();
  2794.   if (th.akt_wdw[0] != '!'){
  2795.     XbWFWd_SwitchTo(th.akt_wdw,0);
  2796.     };
  2797.   XbWFWd_DrawAll();
  2798.  
  2799.   return(0);
  2800.   };
  2801. /*}}}  */
  2802.  
  2803. /*{{{  XbWFMf_ExecCom(     ***    Unterroutinen Metafile-Interpreter*/
  2804. void  XbWFMf_ExecCom(char *com){
  2805.   char sstr[100];
  2806.   int stat;
  2807.   stat = XbWFMf_GtComNo(com);
  2808.   if (stat >= 0){
  2809.     if (XbWFMf_ExComand(stat,0)) {
  2810.       sprintf(sstr,"Sorry: %s !OK (l.%d) %s",(char *)com,
  2811.         (int)XbWVMf_az,(char *)XbWVMf_af);
  2812.       XbWFTb_Error(sstr);
  2813.       };
  2814.     };
  2815.   return;
  2816.   };
  2817. /*}}}  */
  2818. /*{{{  XbWFMf_DebugON(     ****/
  2819. void  XbWFMf_DebugON(void){
  2820.   XbWVMf_prd = 1;
  2821.   };
  2822. /*}}}  */
  2823. /*{{{  XbWFMf_SetNames(    ****/
  2824. int  XbWFMf_SetNames(char *lzeile){
  2825.   int ii;
  2826.   /*  Format : <LISTE>:<GRUPPE>.<Element> */
  2827.   if (strchr(lzeile,':') == NULL) {return(1);};
  2828.   if (strchr(lzeile,'.') == NULL) {return(1);};
  2829.   strncpy(XbWVMf_ln,&lzeile[0],129);
  2830.   XbWVMf_ln[129]=0; *((char*)(strchr(XbWVMf_ln,':')))=0;
  2831.   strncpy(XbWVMf_gn,strchr(lzeile,':')+1,129); XbWVMf_gn[129]= 0;
  2832.   *((char*)(strchr(XbWVMf_gn,'.')))=0;
  2833.   strncpy(XbWVMf_nn,strchr(lzeile,'.')+1,129); XbWVMf_nn[129]= 0;
  2834.   for (ii=0;ii<129;ii++){
  2835.     switch(XbWVMf_nn[ii]) {
  2836.       case ';':
  2837.       case ',':
  2838.       case '|':
  2839.       case ' ':
  2840.       case '\t':
  2841.       case '}': XbWVMf_nn[ii]=0;ii=1000;break;
  2842.       };
  2843.     };
  2844.   return(0);
  2845.   };
  2846. /*}}}  */
  2847. /*{{{  XbWFMf_EndOfMta(    ****/
  2848. void  XbWFMf_EndOfMta(void){
  2849.   XbWVMf_eof = 1;};
  2850. /*}}}  */
  2851. /*{{{  XbWFMf_GotoLabl(    ****/
  2852. void  XbWFMf_GotoLabl(void *p[1]){
  2853.   strcpy(XbWVMf_jln,"!");
  2854.   strcat(XbWVMf_jln,(char *)p[0]);
  2855.   strcat(XbWVMf_jln,"!");
  2856.   XbWVMf_jtl = 1;
  2857.   };
  2858. /*}}}  */
  2859. /*{{{  XbWFMf_PtrStr(      ****/
  2860. void  XbWFMf_PtrStr(char *zeile,char*rohzeile, int *r_a, int *r_l, FILE *MetaFile){
  2861.   int r_akt,r_len;
  2862.   int ii=0;
  2863.   int mm=0;
  2864.   r_akt = *r_a;
  2865.   r_len = *r_l;
  2866.   while(!mm)
  2867.     {
  2868.     switch (rohzeile[r_akt])
  2869.       {
  2870.       case  0 : mm++; zeile[ii]=0; break;
  2871.       case '|': mm++; zeile[ii]=0; break;
  2872.       case ' ': mm++; zeile[ii]=0; break;
  2873.       case '\t': mm++; zeile[ii]=0; break;
  2874.       case '}': mm++; zeile[ii]=0; break;
  2875.       case ',': mm++; zeile[ii]=0; break;
  2876.       case '>': mm++; zeile[ii]=0; break;
  2877.       case '$':
  2878.           {
  2879.           int ll,kk;
  2880.           char *parstr;
  2881.           r_akt++;
  2882.           XbWDMf_GtLine;
  2883.           if (XbWVMf_eof){goto end_of_read;};
  2884.           ll = rohzeile[r_akt] - '0';
  2885.           r_akt++;
  2886.           XbWDMf_GtLine;
  2887.           if (XbWVMf_eof){goto end_of_read;};
  2888.           if (rohzeile[r_akt] >= '0')
  2889.             {
  2890.             if (rohzeile[r_akt] <= '9')
  2891.               {
  2892.               ll *= 10;
  2893.               ll += rohzeile[r_akt]-'0';
  2894.               r_akt ++;
  2895.               XbWDMf_GtLine;
  2896.               };
  2897.             };
  2898.           if (XbWVMf_aP != NULL){
  2899.             parstr = (char*)((*XbWVMf_aP)[ll]).XbWVMf_P;
  2900.             kk = 0;
  2901.             while (parstr[kk] != 0){
  2902.               zeile[ii] = parstr[kk]; ii++; kk++;
  2903.               };
  2904.             };
  2905.           };
  2906.           break;
  2907.       case '<':
  2908.           {
  2909.           char s_zz[80];
  2910.           XbWFMf_PtrStr(s_zz,rohzeile,&r_akt,&r_len,MetaFile);
  2911.           if (!XbWFMf_SetNames(s_zz))
  2912.             {
  2913.             char *parstr;
  2914.             int s_kk;
  2915.             XbWDDb_DbIVar  *ac_gp;
  2916.             if ((ac_gp = XbWFDb_FindGrp(XbWVMf_ln,XbWVMf_gn)) != NULL){
  2917.               parstr = (char*)XbWFDb_VarInh(ac_gp,XbWDDb_Str,XbWVMf_nn,1);
  2918.               if (parstr != NULL) {
  2919.                 s_kk = 0;
  2920.                 while (parstr[s_kk] != 0){
  2921.                   zeile[ii] = parstr[s_kk]; ii++; s_kk++;
  2922.                   };
  2923.                 };
  2924.               };
  2925.             };
  2926.           };
  2927.           break;
  2928.       default :
  2929.         zeile[ii] = rohzeile[r_akt]; ii++;
  2930.         r_akt++; XbWDMf_GtLine; break;
  2931.       };
  2932.     };
  2933.   end_of_read:;
  2934.   zeile[ii] = 0;
  2935.   *r_a = r_akt;
  2936.   *r_l = r_len;
  2937.   };
  2938. /*}}}  */
  2939. /*{{{  XbWFMf_VPtr(        ****/
  2940. void  XbWFMf_VPtr(char *zeile,char*rohzeile, int *r_a, int *r_l, FILE *MetaFile, int *s_p){
  2941.   int r_akt,r_len,StarteProcedure;
  2942.   char r_p;
  2943.   r_akt = *r_a;
  2944.   r_len = *r_l;
  2945.   StarteProcedure = *s_p;
  2946.   r_akt++;
  2947.   XbWDMf_GtLine;
  2948.   if (XbWVMf_eof){goto end_of_read;};
  2949.   r_p = rohzeile[r_akt];
  2950.   r_akt++;
  2951.   XbWDMf_GtLine;
  2952.   if (XbWVMf_eof){goto end_of_read;};
  2953.   XbWFMf_PtrStr(zeile,rohzeile,&r_akt,&r_len,MetaFile);
  2954.   switch(r_p)
  2955.     {
  2956.     case 'p':
  2957.       {
  2958.       int dd;
  2959.       if (!XbWFMf_SetNames(zeile)) {
  2960.         XbWDDb_DbIVar  *ac_gp;
  2961.         ac_gp = XbWFDb_FindGrp(XbWVMf_ln,XbWVMf_gn);
  2962.         if (ac_gp != NULL) {
  2963.           dd = XbWFDb_GetNum(ac_gp,XbWVMf_nn,1);
  2964.           XbWVMf_P[XbWVMf_C] = (void  *)dd;
  2965.           XbWVMf_T[XbWVMf_C] = XbWDMf_VPPar;
  2966.           XbWVMf_C++;
  2967.           };
  2968.         XbWDMf_SekEOL;
  2969.         };
  2970.       };
  2971.       break;
  2972.     case 'i':
  2973.       {
  2974.       int dda=0; int *dd=&dda;
  2975.       if (!XbWFMf_SetNames(zeile))
  2976.         {
  2977.         XbWDDb_DbIVar  *ac_gp;
  2978.         ac_gp = XbWFDb_FindGrp(XbWVMf_ln,XbWVMf_gn);
  2979.         if (ac_gp != NULL) {
  2980.           ac_gp = (XbWDDb_DbIVar  *)XbWFDb_VarInh(ac_gp,0,XbWVMf_nn,1);
  2981.           switch( ac_gp->tp & XbWDDb_Typ) {
  2982.             case XbWDDb_Int:  dd = (int*)&((XbWDDb_DbIInt  *)ac_gp)->inh; break;
  2983.             case XbWDDb_Dbl:  dd = (int*)&((XbWDDb_DbIDbl  *)ac_gp)->inh; break;
  2984.             case XbWDDb_Str:  dd = (int*)&(((XbWDDb_DbIStr  *)ac_gp)->nmi[ac_gp->tp & XbWDDb_NLen]); break;
  2985.             case XbWDDb_NPtr:
  2986.             case XbWDDb_FPtr:
  2987.             case XbWDDb_IPtr:
  2988.             case XbWDDb_GPtr: dd = (int*)&((XbWDDb_DbINPtr  *)ac_gp)->inh; break;
  2989.             };
  2990.           };
  2991.         XbWVMf_P[XbWVMf_C] = (void  *)dd;
  2992.         XbWVMf_T[XbWVMf_C] = XbWDMf_VIPar;
  2993.         XbWVMf_C++;
  2994.         XbWDMf_SekEOL;
  2995.         };
  2996.       };
  2997.       break;
  2998.     case 'm':
  2999.       {
  3000.       char *dd;
  3001.       if (!XbWFMf_SetNames(zeile))
  3002.         {
  3003.         XbWDDb_DbIVar  *ac_gp;
  3004.         ac_gp = XbWFDb_FindGrp(XbWVMf_ln,XbWVMf_gn);
  3005.         if (ac_gp != NULL) {
  3006.           dd = (char *)XbWFDb_VarInh(ac_gp,XbWDDb_Str,XbWVMf_nn,1);
  3007.           if (dd != NULL) { XbWFMf_ReadMakro(dd); };
  3008.           };
  3009.         XbWDMf_SekEOL;
  3010.         };
  3011.       };
  3012.       break;
  3013.     case 'l':
  3014.       {
  3015.       int *dd;
  3016.       if (!XbWFMf_SetNames(zeile))
  3017.         {
  3018.         dd = (int*)XbWFDb_GetDbI(XbWVMf_ln,XbWVMf_gn,XbWVMf_nn);
  3019.         XbWVMf_P[XbWVMf_C] = (void  *)dd;
  3020.         XbWVMf_T[XbWVMf_C] = XbWDMf_VLPar;
  3021.         XbWVMf_C++;
  3022.         XbWDMf_SekEOL;
  3023.         };
  3024.       };
  3025.       break;
  3026.     };
  3027.   end_of_read:;
  3028.   *r_a = r_akt;
  3029.   *r_l = r_len;
  3030.   *s_p = StarteProcedure;
  3031.   };
  3032. /*}}}  */
  3033. /*{{{  XbWFMf_VPtrKl(      ****/
  3034. void  XbWFMf_VPtrKl(char *zeile,char*rohzeile, int *r_a, int *r_l, FILE *MetaFile, int *s_p){
  3035.   int r_akt,r_len,StarteProcedure;
  3036.   char r_p;
  3037.   r_akt = *r_a;
  3038.   r_len = *r_l;
  3039.   StarteProcedure = *s_p;
  3040.   r_akt++;
  3041.   XbWDMf_GtLine;
  3042.   if (XbWVMf_eof){goto end_of_read;};
  3043.   r_p = rohzeile[r_akt];
  3044.   r_akt++;
  3045.   XbWDMf_GtLine;
  3046.   { char dummy=0;
  3047.     while (dummy != ')' ){
  3048.       dummy = rohzeile[r_akt];
  3049.       r_akt++;
  3050.       XbWDMf_GtLine;
  3051.       };
  3052.     };
  3053.   if (XbWVMf_eof){goto end_of_read;};
  3054.   XbWFMf_PtrStr(zeile,rohzeile,&r_akt,&r_len,MetaFile);
  3055.  
  3056.   switch(r_p)
  3057.     {
  3058.     /*{{{  case 'i':   (int)*/
  3059.     case 'i':  /* (int) */
  3060.       {
  3061.       int dd;
  3062.       if (!XbWFMf_SetNames(zeile)) {
  3063.         XbWDDb_DbIVar  *ac_gp;
  3064.         ac_gp = XbWFDb_FindGrp(XbWVMf_ln,XbWVMf_gn);
  3065.         if (ac_gp != NULL) {
  3066.           dd = XbWFDb_GetNum(ac_gp,XbWVMf_nn,1);
  3067.           XbWVMf_P[XbWVMf_C] = (void  *)dd;
  3068.           XbWVMf_T[XbWVMf_C] = XbWDMf_VPPar;
  3069.           XbWVMf_C++;
  3070.           };
  3071.         XbWDMf_SekEOL;
  3072.         };
  3073.       };
  3074.       break;
  3075.     /*}}}  */
  3076.     /*{{{  case 'v':   (val)*/
  3077.     case 'v':  /* (val) */
  3078.       {
  3079.       int dda=0; int *dd=&dda;
  3080.       if (!XbWFMf_SetNames(zeile))
  3081.         {
  3082.         XbWDDb_DbIVar  *ac_gp;
  3083.         ac_gp = XbWFDb_FindGrp(XbWVMf_ln,XbWVMf_gn);
  3084.         if (ac_gp != NULL) {
  3085.           ac_gp = (XbWDDb_DbIVar  *)XbWFDb_VarInh(ac_gp,0,XbWVMf_nn,1);
  3086.           switch( ac_gp->tp & XbWDDb_Typ) {
  3087.             case XbWDDb_Int:  dd = (int*)&((XbWDDb_DbIInt  *)ac_gp)->inh; break;
  3088.             case XbWDDb_Dbl:  dd = (int*)&((XbWDDb_DbIDbl  *)ac_gp)->inh; break;
  3089.             case XbWDDb_Str:  dd = (int*)&(((XbWDDb_DbIStr  *)ac_gp)->nmi[ac_gp->tp & XbWDDb_NLen]); break;
  3090.             case XbWDDb_NPtr:
  3091.             case XbWDDb_FPtr:
  3092.             case XbWDDb_IPtr:
  3093.             case XbWDDb_GPtr: dd = (int*)&((XbWDDb_DbINPtr  *)ac_gp)->inh; break;
  3094.             };
  3095.           };
  3096.         XbWVMf_P[XbWVMf_C] = (void  *)dd;
  3097.         XbWVMf_T[XbWVMf_C] = XbWDMf_VIPar;
  3098.         XbWVMf_C++;
  3099.         XbWDMf_SekEOL;
  3100.         };
  3101.       };
  3102.       break;
  3103.     /*}}}  */
  3104.     /*{{{  case 's':   (str)  val = str !!!*/
  3105.     case 's':  /* (str) */
  3106.       {
  3107.       int dda=0; int *dd=&dda;
  3108.       if (!XbWFMf_SetNames(zeile))
  3109.         {
  3110.         XbWDDb_DbIVar  *ac_gp;
  3111.         ac_gp = XbWFDb_FindGrp(XbWVMf_ln,XbWVMf_gn);
  3112.         if (ac_gp != NULL) {
  3113.           ac_gp = (XbWDDb_DbIVar  *)XbWFDb_VarInh(ac_gp,0,XbWVMf_nn,1);
  3114.           switch( ac_gp->tp & XbWDDb_Typ) {
  3115.             case XbWDDb_Int:  dd = (int*)&((XbWDDb_DbIInt  *)ac_gp)->inh; break;
  3116.             case XbWDDb_Dbl:  dd = (int*)&((XbWDDb_DbIDbl  *)ac_gp)->inh; break;
  3117.             case XbWDDb_Str:  dd = (int*)&(((XbWDDb_DbIStr  *)ac_gp)->nmi[ac_gp->tp & XbWDDb_NLen]); break;
  3118.             case XbWDDb_NPtr:
  3119.             case XbWDDb_FPtr:
  3120.             case XbWDDb_IPtr:
  3121.             case XbWDDb_GPtr: dd = (int*)&((XbWDDb_DbINPtr  *)ac_gp)->inh; break;
  3122.             };
  3123.           };
  3124.         XbWVMf_P[XbWVMf_C] = (void  *)dd;
  3125.         XbWVMf_T[XbWVMf_C] = XbWDMf_VIPar;
  3126.         XbWVMf_C++;
  3127.         XbWDMf_SekEOL;
  3128.         };
  3129.       };
  3130.       break;
  3131.     /*}}}  */
  3132.     /*{{{  case 'm':   (mak)*/
  3133.     case 'm':     /* (mak) */
  3134.       {
  3135.       char *dd;
  3136.       if (!XbWFMf_SetNames(zeile))
  3137.         {
  3138.         XbWDDb_DbIVar  *ac_gp;
  3139.         ac_gp = XbWFDb_FindGrp(XbWVMf_ln,XbWVMf_gn);
  3140.         if (ac_gp != NULL) {
  3141.           dd = (char *)XbWFDb_VarInh(ac_gp,XbWDDb_Str,XbWVMf_nn,1);
  3142.           if (dd != NULL) { XbWFMf_ReadMakro(dd); };
  3143.           };
  3144.         XbWDMf_SekEOL;
  3145.         };
  3146.       };
  3147.       break;
  3148.     /*}}}  */
  3149.     /*{{{  case 'p':   (ptr)*/
  3150.     case 'p':    /* (ptr) */
  3151.       {
  3152.       int *dd;
  3153.       if (!XbWFMf_SetNames(zeile))
  3154.         {
  3155.         dd = (int*)XbWFDb_GetDbI(XbWVMf_ln,XbWVMf_gn,XbWVMf_nn);
  3156.         XbWVMf_P[XbWVMf_C] = (void  *)dd;
  3157.         XbWVMf_T[XbWVMf_C] = XbWDMf_VLPar;
  3158.         XbWVMf_C++;
  3159.         XbWDMf_SekEOL;
  3160.         };
  3161.       };
  3162.       break;
  3163.     
  3164.     /*}}}  */
  3165.  
  3166.     };
  3167.   end_of_read:;
  3168.   *r_a = r_akt;
  3169.   *r_l = r_len;
  3170.   *s_p = StarteProcedure;
  3171.   };
  3172. /*}}}  */
  3173. /*{{{  XbWFMf_RdCompMak(   ****/
  3174. void  XbWFMf_RdCompMak(XbWDDb_DbIVar  *start){
  3175.   int ii;
  3176.   XbWDDb_DbIVar  *TV;
  3177.   int Command = 0;
  3178.   char  *mfname = NULL;
  3179.   TV = (XbWDDb_DbIVar  *)start;
  3180.   XbWVMf_eof = 0;
  3181.   while(!XbWVMf_eof){
  3182.     XbWFDb_ForWd(&TV,XbWDDb_DbISys);
  3183.     switch(TV->tp & XbWDDb_Typ){
  3184.       case XbWDDb_Int:
  3185.         Command = ((XbWDDb_DbIInt  *)TV)->inh;
  3186.         if (XbWVMf_eof) { return; };
  3187.         mfname = NULL;
  3188.         break;
  3189.       case XbWDDb_Str:
  3190.         Command = 0;
  3191.         mfname = (char  *)XbWFDb_GetStr((XbWDDb_DbIStr  *)TV);
  3192.         break;
  3193.       };
  3194.     XbWFDb_ForWd(&TV,XbWDDb_DbISys);
  3195.     XbWVMf_C = 0;
  3196.     switch(TV->tp & XbWDDb_Typ){
  3197.       case XbWDDb_Int:
  3198.         XbWVMf_C = ((XbWDDb_DbIInt  *)TV)->inh;
  3199.         break;
  3200.       };
  3201.     XbWVMf_P[0] = (void  *)XbWVMf_C;
  3202.     for (ii=1;ii<=XbWVMf_C;ii++) {
  3203.       XbWFDb_ForWd(&TV,XbWDDb_DbISys);
  3204.       switch((TV->tp)&XbWDDb_Typ)
  3205.         {
  3206.         case XbWDDb_Str:
  3207.           XbWVMf_T[ii] = XbWDMf_StrPar;
  3208.           XbWVMf_P[ii] = (void  *)XbWFDb_GetStr((XbWDDb_DbIStr  *)TV);
  3209.           break;
  3210.         case XbWDDb_Dbl:
  3211.           XbWVMf_T[ii] = XbWDMf_DblPar;
  3212.           sprintf((char*)&XbWVMf_B[ii*XbWDMf_BfStrL],"%20.10f",
  3213.             XbWFDb_GetNum(TV,NULL,1));
  3214.           XbWVMf_P[ii] = (void *)&(XbWVMf_B[ii*XbWDMf_BfStrL]);
  3215.           break;
  3216.         case XbWDDb_Int:
  3217.           XbWVMf_T[ii] = XbWDMf_IntPar;
  3218.           { int dd;
  3219.           dd = XbWFDb_GetNum(TV,NULL,1);
  3220.           XbWVMf_P[ii] = (void  *)dd;
  3221.           }
  3222.           break;
  3223.         case XbWDDb_IPtr:
  3224.           XbWVMf_T[ii] = XbWDMf_VIPar;
  3225.           XbWVMf_P[ii] = XbWFDb_CDbIToPtr( ((XbWDDb_DbINPtr  *)TV)->inh,XbWDDb_DbISys);
  3226.           break;
  3227.         case XbWDDb_NPtr:
  3228.           XbWVMf_T[ii] = XbWDMf_VLPar;
  3229.           XbWVMf_P[ii] = XbWFDb_CDbIToPtr( ((XbWDDb_DbINPtr  *)TV)->inh,XbWDDb_DbISys);
  3230.           break;
  3231.         };
  3232.       };
  3233.     if (mfname == NULL) {
  3234.       if (XbWFMf_ExComand(Command,0) != 0) {
  3235.         XbWFTb_Error("Sorry: Compiled Makro not OK. ");
  3236.         };
  3237.       }
  3238.     else {
  3239.       XbWFMf_ReadMF((char*)mfname);
  3240.       };
  3241.     };
  3242.   };
  3243. /*}}}  */
  3244. /*{{{  XbWFMf_InterpretMF( ***    Haupt-Unterroutine fuer Interpreter*/
  3245. void  XbWFMf_InterpretMF(
  3246.     FILE *MetaFile, char *rohzeile, int compile_target){
  3247.   int StarteProcedure = 0;
  3248.   int minus_val;
  3249.   int r_len;
  3250.   int r_akt;
  3251.   int AutoMetaMode = 0;
  3252.   char ProcName[65];
  3253.   char zeile[50];
  3254.   #ifdef TEST
  3255.     XbWFTb_Message("start interpreter");
  3256.     #endif
  3257.   if (MetaFile == NULL){
  3258.     r_akt = 0; r_len = strlen(rohzeile)+1;
  3259.     }
  3260.   else {
  3261.     r_akt = 0; r_len = fread(rohzeile,1,256,MetaFile);
  3262.     };
  3263.   ProcName[0] = 0;
  3264.   XbWVMf_eof = 0;
  3265.   #ifdef TEST
  3266.     XbWFTb_Message("zeile lesen");
  3267.     #endif
  3268.   XbWVSy_DebugCommand = ProcName;
  3269.   XbWVSy_DebugLine = rohzeile;
  3270.   if (r_len > 0)
  3271.     while (!XbWVMf_eof){
  3272.       {
  3273.       nochmal_1:;
  3274.       XbWVSy_DebugLinePos = &rohzeile[r_akt];
  3275.       XbWDMf_GtLine;
  3276.       if (XbWVMf_eof){goto end_of_read;};
  3277.       switch(rohzeile[r_akt])
  3278.         {
  3279.         case ' ':  r_akt++; goto nochmal_1;
  3280.         case ',':  r_akt++; goto nochmal_1;
  3281.         case '|':  r_akt++; goto nochmal_1;
  3282.         case '\t': r_akt++; goto nochmal_1;
  3283.         case 10: r_akt++; goto nochmal_1;
  3284.         case 13: r_akt++; goto nochmal_1;
  3285.         };
  3286.       XbWDMf_GtLine;
  3287.       if (XbWVMf_eof){goto end_of_read;};
  3288.       switch(rohzeile[r_akt])
  3289.         {
  3290. /* ---------------- */
  3291. /*{{{  case 'm':*/
  3292.         case 'm':
  3293.           {
  3294.           int ll;
  3295.           if ( (rohzeile[r_akt+1] >= '0') &
  3296.                (rohzeile[r_akt+1] <= '9') ) {
  3297.             }
  3298.           else {
  3299.             goto read_string;
  3300.             };
  3301.  
  3302.           r_akt++;
  3303.           XbWDMf_GtLine;
  3304.           if (XbWVMf_eof){goto end_of_read;};
  3305.           ll = rohzeile[r_akt] - '0';
  3306.           r_akt++;
  3307.           XbWDMf_GtLine;
  3308.           if (XbWVMf_eof){goto end_of_read;};
  3309.           if (rohzeile[r_akt] >= '0')
  3310.             {
  3311.             if (rohzeile[r_akt] <= '9')
  3312.               {
  3313.               ll *= 10;
  3314.               ll += rohzeile[r_akt]-'0';
  3315.               r_akt ++;
  3316.               XbWDMf_GtLine;
  3317.               };
  3318.             };
  3319.           XbWDMf_SekEOL;
  3320.           if (XbWVMf_aP != NULL){
  3321.             XbWFMf_ReadMakro((char*)((*XbWVMf_aP)[ll]).XbWVMf_P);
  3322.             }
  3323.           else {
  3324.             XbWFTb_Error("Bad or missing metafile parameters!");
  3325.             };
  3326.           };
  3327.           break;
  3328. /*}}}  */
  3329.  
  3330. /* ---------------- */
  3331. /*{{{  case '\\':*/
  3332.         case '\\':
  3333.           {
  3334.           if (XbWVMf_dmf) {
  3335.             char strz[100];
  3336.             sprintf(strz,"Line: ");
  3337.             strncat(strz,rohzeile,80);
  3338.             XbWFTb_Message(strz);
  3339.             XbWSMs_WaitKey();
  3340.             };
  3341.           r_akt++;
  3342.           XbWDMf_GtLine;
  3343.           #ifdef TEST
  3344.             XbWFTb_Message("Kommando lesen");
  3345.             #endif
  3346.           if (XbWVMf_eof){goto end_of_read;};
  3347.           StarteProcedure = 0;
  3348.           XbWVMf_C = 1;
  3349.           XbWDMf_CpyCom(ProcName);
  3350.           XbWDMf_SekEOL;
  3351.           AutoMetaMode = 0;
  3352.           if (XbWVMf_eof){
  3353.             if (strcmp(ProcName,"End") == 0){
  3354.               goto end_of_read;
  3355.               };
  3356.             };
  3357.           };
  3358.           #ifdef TEST
  3359.             XbWFTb_Message("Kommando eingelesen");
  3360.             #endif
  3361.           break;
  3362. /*}}}  */
  3363.  
  3364. /* ---------------- */
  3365. /*{{{  case ':':          Kommando mit neuen Parametern wiederholen*/
  3366.         case ':':       /* Kommando mit neuen Parametern wiederholen */
  3367.           if (XbWVMf_dmf) {
  3368.             char strz[100];
  3369.             sprintf(strz,"Line: ");
  3370.             strncat(strz,rohzeile,80);
  3371.             XbWFTb_Message(strz);
  3372.             XbWSMs_WaitKey();
  3373.             };
  3374.           StarteProcedure = 0;
  3375.           XbWVMf_C = 1;
  3376.           XbWDMf_SekEOL;
  3377.           /* Autometamode unverändert !! */
  3378.           break;
  3379. /*}}}  */
  3380.  
  3381. /* ---------------- */
  3382. /*{{{  case '-':*/
  3383.         case '-':
  3384.           r_akt++; XbWDMf_GtLine;
  3385.           if (XbWVMf_eof){goto end_of_read;};
  3386.           minus_val= -1;
  3387.           goto int_lesen;
  3388. /*}}}  */
  3389.  
  3390. /*{{{  case 'i':*/
  3391.         case 'i':
  3392.         case '+':
  3393.           if ( (rohzeile[r_akt+1] >= '0') &
  3394.                (rohzeile[r_akt+1] <= '9') ) {
  3395.             }
  3396.           else {
  3397.             goto read_string;
  3398.             };
  3399.           r_akt++; XbWDMf_GtLine;
  3400.           if (XbWVMf_eof){goto end_of_read;};
  3401.           minus_val = 1;
  3402.           goto int_lesen;
  3403. /*}}}  */
  3404.  
  3405.         case '0':
  3406.         case '1':
  3407.         case '2':
  3408.         case '3':
  3409.         case '4':
  3410.         case '5':
  3411.         case '6':
  3412.         case '7':
  3413.         case '8':
  3414. /*{{{  case '9':*/
  3415.         case '9':
  3416.  
  3417.           minus_val = 1;
  3418.           int_lesen:;
  3419.           {
  3420.           long ll;
  3421.           int mm=0;
  3422.           ll = 0;
  3423.           while(!mm)
  3424.             {
  3425.             switch (rohzeile[r_akt])
  3426.               {
  3427.               case 10 : mm++; break;
  3428.               case 13 : mm++; break;
  3429.               case  0 : mm++; break;
  3430.               case '}': mm++; break;
  3431.               case '|': mm++; break;
  3432.               case ' ': mm++; break;
  3433.               case '\t': mm++; break;
  3434.               case ',': mm++; break;
  3435.               case '-': ll *= -1;
  3436.               case '+':
  3437.               case '0':
  3438.               case '1':
  3439.               case '2':
  3440.               case '3':
  3441.               case '4':
  3442.               case '5':
  3443.               case '6':
  3444.               case '7':
  3445.               case '8':
  3446.               case '9':
  3447.                 ll *= 10;
  3448.                 ll += rohzeile[r_akt] - '0';
  3449.                 r_akt++; XbWDMf_GtLine; break;
  3450.               default: {
  3451.                 char sstr[80];
  3452.                 sprintf(sstr,"Is no integer: %s ",(char*)&rohzeile[r_akt]);
  3453.                 XbWSPu_Alarm(sstr); mm++; break;
  3454.                 };
  3455.               };
  3456.             };
  3457.           XbWDMf_SekEOL;
  3458.           XbWVMf_P[XbWVMf_C] = (void  *)((int)(ll * minus_val));
  3459.           XbWVMf_T[XbWVMf_C] = XbWDMf_IntPar;
  3460.           XbWVMf_C +=1;
  3461.           };
  3462.           break;
  3463. /*}}}  */
  3464.  
  3465. /* ---------------- */
  3466. /*{{{  case '\"':*/
  3467.         case '\"':
  3468.           {
  3469.           char *cp;
  3470.           int ii=0;
  3471.           int mm=0;
  3472.           #ifdef TEST
  3473.             XbWFTb_Message("Stringpara");
  3474.             #endif
  3475.           r_akt++;
  3476.           XbWDMf_GtLine;
  3477.           if (XbWVMf_eof){goto end_of_read;};
  3478.           cp = (char*)&XbWVMf_B[XbWVMf_C*XbWDMf_BfStrL];
  3479.           while(!mm)  {
  3480.             switch (rohzeile[r_akt])
  3481.               {
  3482.               case 10 : mm++; cp[ii]=0;break;
  3483.               case 13 : mm++; cp[ii]=0;break;
  3484.               case  0 : mm++; cp[ii]=0;break;
  3485.               case '"': mm++; cp[ii]=0; break;
  3486.               case '\'': cp[ii] = '"'; ii++; r_akt++; XbWDMf_GtLine; break;
  3487.               case '$': /* Insert parameter as string */
  3488.                 /*{{{  */
  3489.                 {
  3490.                   int ll;
  3491.                   int ccc;
  3492.                   char *insert_string="(xbw:???)";
  3493.                   r_akt++;
  3494.                   XbWDMf_GtLine;
  3495.                   if (XbWVMf_eof){goto end_of_read;};
  3496.                   ll = rohzeile[r_akt] - '0';
  3497.                   r_akt++;
  3498.                   XbWDMf_GtLine;
  3499.                   if (XbWVMf_eof){goto end_of_read;};
  3500.                   if (rohzeile[r_akt] >= '0')
  3501.                     {
  3502.                     if (rohzeile[r_akt] <= '9')
  3503.                       {
  3504.                       ll *= 10;
  3505.                       ll += rohzeile[r_akt]-'0';
  3506.                       r_akt ++;
  3507.                       XbWDMf_GtLine;
  3508.                       if (XbWVMf_eof){goto end_of_read;};
  3509.                       };
  3510.                     };
  3511.                   if (XbWVMf_aP != NULL) {
  3512.                     switch ((*XbWVMf_aP)[ll].XbWVMf_T){
  3513.                       case XbWDMf_StrPar:
  3514.                         insert_string = (void  *)((*XbWVMf_aP)[ll]).XbWVMf_P;
  3515.                         break;
  3516.                       case XbWDMf_IntPar:
  3517.                         sprintf(insert_string,"%d",(int)((*XbWVMf_aP)[ll]).XbWVMf_P);
  3518.                         break;
  3519.                       case XbWDMf_DblPar:
  3520.                         sprintf(insert_string,"%s",(char *)((*XbWVMf_aP)[ll]).XbWVMf_P);
  3521.                         break;
  3522.                       case XbWDMf_VLPar:
  3523.                         {
  3524.                           XbWDDb_DbIVar  * TV;
  3525.                           TV = (XbWDDb_DbIVar  *)((*XbWVMf_aP)[ll]).XbWVMf_P;
  3526.                           insert_string = XbWFDb_GetNam(TV);
  3527.                           };
  3528.                         break;
  3529.                       };
  3530.                     }
  3531.                   else {
  3532.                     XbWFTb_Error("Not enough metafile parameters");
  3533.                     };
  3534.                 
  3535.                   ccc = 0;
  3536.                   while(insert_string[ccc] != 0){
  3537.                     cp[ii] = insert_string[ccc]; ii++;
  3538.                     ccc++;
  3539.                     };
  3540.                   };
  3541.                 /*}}}  */
  3542.                 break;
  3543.  
  3544.               default :
  3545.                 cp[ii] = rohzeile[r_akt]; ii++;
  3546.                 r_akt++; XbWDMf_GtLine; break;
  3547.               };
  3548.             };
  3549.           XbWVMf_P[XbWVMf_C] = (char  *)&XbWVMf_B[XbWVMf_C*XbWDMf_BfStrL];
  3550.           XbWVMf_T[XbWVMf_C] = XbWDMf_StrPar;
  3551.           XbWVMf_C++;
  3552.           XbWDMf_SekEOL;
  3553.           #ifdef TEST
  3554.             XbWFTb_Message("Stringpara fertig");
  3555.             #endif
  3556.           };
  3557.           break;
  3558. /*}}}  */
  3559.  
  3560. /* ---------------- */
  3561. /*{{{  case '{':*/
  3562.         case '{':
  3563.           {
  3564.           char *cp;
  3565.           int ii=0;
  3566.           int mm=0;
  3567.           r_akt++;
  3568.           XbWDMf_GtLine;
  3569.           if (XbWVMf_eof){goto end_of_read;};
  3570.           cp = (char*)&XbWVMf_B[XbWVMf_C*XbWDMf_BfStrL];
  3571.           while(!mm) {
  3572.             switch (rohzeile[r_akt]) {
  3573.               case  0 : mm++; cp[ii]=0; break;
  3574.               case '}': mm++; cp[ii]=0; break;
  3575.               default :
  3576.                 cp[ii] = rohzeile[r_akt]; ii++;
  3577.                 r_akt++; XbWDMf_GtLine; break;
  3578.               };
  3579.             };
  3580.           XbWVMf_P[XbWVMf_C] = (char  *)&XbWVMf_B[XbWVMf_C*XbWDMf_BfStrL];
  3581.           XbWVMf_T[XbWVMf_C] = XbWDMf_DblPar;
  3582.           XbWVMf_C++;
  3583.           XbWDMf_SekEOL;
  3584.           };
  3585.           break;
  3586. /*}}}  */
  3587.  
  3588. /* ---------------- */
  3589.         case '%':
  3590. /* ---------------- */
  3591.         case '/':
  3592. /* ---------------- */
  3593. /*{{{  case '!':*/
  3594.         case '!':
  3595.           XbWDMf_IgnLin;
  3596.           break;
  3597. /*}}}  */
  3598.  
  3599. /* ---------------- */
  3600. /*{{{  case '}':*/
  3601.         case '}':
  3602.           XbWDMf_SekEOL;
  3603.           break;
  3604. /*}}}  */
  3605.  
  3606. /* ---------------- */
  3607. /*{{{  case '(':*/
  3608.         case '(':
  3609.           XbWFMf_VPtrKl(zeile,rohzeile,&r_akt,&r_len,MetaFile,&StarteProcedure);
  3610.           break;
  3611. /*}}}  */
  3612.  
  3613. /* ---------------- */
  3614. /*{{{  case 'v':*/
  3615.         case 'v':
  3616.           if ( (rohzeile[r_akt+1] != 'l') &
  3617.                (rohzeile[r_akt+1] != 'i') &
  3618.                (rohzeile[r_akt+1] != 'm') &
  3619.                (rohzeile[r_akt+1] != 'p') ) {
  3620.             goto read_string;
  3621.             };
  3622.           XbWFMf_VPtr(zeile,rohzeile,&r_akt,&r_len,MetaFile,&StarteProcedure);
  3623.           break;
  3624. /*}}}  */
  3625.  
  3626. /* ---------------- */
  3627. /*{{{  case 'N':*/
  3628.         case 'N':
  3629.           if ( (rohzeile[r_akt+1] != 'U') &
  3630.                (rohzeile[r_akt+2] != 'L') &
  3631.                (rohzeile[r_akt+3] != 'L') ) {
  3632.             goto read_string;
  3633.             };
  3634.           XbWVMf_P[XbWVMf_C] = NULL;
  3635.           XbWVMf_T[XbWVMf_C] = XbWDMf_NULPar;
  3636.           XbWVMf_C++;
  3637.           XbWDMf_SekEOL;
  3638.           break;
  3639. /*}}}  */
  3640.  
  3641. /* ---------------- */
  3642. /*{{{  case '@':*/
  3643.         case '@':
  3644.           {
  3645.           if (XbWVMf_dmf) {
  3646.             char strz[100];
  3647.             sprintf(strz,"Line: ");
  3648.             strncat(strz,rohzeile,80);
  3649.             XbWFTb_Message(strz);
  3650.             XbWSMs_WaitKey();
  3651.             };
  3652.           XbWDMf_CpyCom(ProcName);
  3653.           XbWDMf_SekEOL;
  3654.           XbWVMf_C = 1;
  3655.           AutoMetaMode = 1;
  3656.           };
  3657.           break;
  3658. /*}}}  */
  3659.  
  3660. /* ---------------- */
  3661. /*{{{  case '$':*/
  3662.         case '$':
  3663.           {
  3664.           int ll;
  3665.           r_akt++;
  3666.           XbWDMf_GtLine;
  3667.           if (XbWVMf_eof){goto end_of_read;};
  3668.           ll = rohzeile[r_akt] - '0';
  3669.           r_akt++;
  3670.           XbWDMf_GtLine;
  3671.           if (XbWVMf_eof){goto end_of_read;};
  3672.           if (rohzeile[r_akt] >= '0')
  3673.             {
  3674.             if (rohzeile[r_akt] <= '9')
  3675.               {
  3676.               ll *= 10;
  3677.               ll += rohzeile[r_akt]-'0';
  3678.               r_akt ++;
  3679.               XbWDMf_GtLine;
  3680.               if (XbWVMf_eof){goto end_of_read;};
  3681.               };
  3682.             };
  3683.           XbWDMf_SekEOL;
  3684.           if (XbWVMf_aP != NULL) {
  3685.             XbWVMf_P[XbWVMf_C] = (void  *)((*XbWVMf_aP)[ll]).XbWVMf_P;
  3686.             XbWVMf_T[XbWVMf_C] = (*XbWVMf_aP)[ll].XbWVMf_T;
  3687.             }
  3688.           else {
  3689.             XbWFTb_Error("Not enough metafile parameters");
  3690.             };
  3691.           XbWVMf_C ++;
  3692.           };
  3693.           break;
  3694. /*}}}  */
  3695.  
  3696. /* ---------------- */
  3697. /*{{{  case 0:*/
  3698.         case 0:
  3699.           XbWVMf_eof = 1;
  3700.           goto end_of_read;
  3701. /*}}}  */
  3702.  
  3703. /* ---------------- */
  3704. /*{{{  default:*/
  3705.         default:
  3706.           read_string:;
  3707.           if ( ( (rohzeile[r_akt]>='A')&(rohzeile[r_akt]<='Z') ) |
  3708.                ( (rohzeile[r_akt]>='a')&(rohzeile[r_akt]<='z') ) |
  3709.                  (rohzeile[r_akt]=='=')                          |
  3710.                  (rohzeile[r_akt]=='.')                           ){
  3711.              char *cp;
  3712.              int ii=0;
  3713.              int mm=0;
  3714.              #ifdef TEST
  3715.                XbWFTb_Message("Stringpara");
  3716.                #endif
  3717.              XbWDMf_GtLine;
  3718.              if (XbWVMf_eof){goto end_of_read;};
  3719.              cp = (char*)&XbWVMf_B[XbWVMf_C*XbWDMf_BfStrL];
  3720.              while(!mm)  {
  3721.                switch (rohzeile[r_akt])
  3722.                  {
  3723.                  case 10 : mm++; cp[ii]=0;break;
  3724.                  case 13 : mm++; cp[ii]=0;break;
  3725.                  case  0 : mm++; cp[ii]=0;break;
  3726.                  case '"': mm++; cp[ii]=0; break;
  3727.                  case ' ': mm++; cp[ii]=0; break;
  3728.                  case '\'': cp[ii] = '"'; ii++; r_akt++; XbWDMf_GtLine; break;
  3729.                  case '$': /* Insert parameter as string */
  3730.                    /*{{{  */
  3731.                    {
  3732.                      int ll;
  3733.                      int ccc;
  3734.                      char *insert_string="(xbw:???)";
  3735.                      r_akt++;
  3736.                      XbWDMf_GtLine;
  3737.                      if (XbWVMf_eof){goto end_of_read;};
  3738.                      ll = rohzeile[r_akt] - '0';
  3739.                      r_akt++;
  3740.                      XbWDMf_GtLine;
  3741.                      if (XbWVMf_eof){goto end_of_read;};
  3742.                      if (rohzeile[r_akt] >= '0')
  3743.                        {
  3744.                        if (rohzeile[r_akt] <= '9')
  3745.                          {
  3746.                          ll *= 10;
  3747.                          ll += rohzeile[r_akt]-'0';
  3748.                          r_akt ++;
  3749.                          XbWDMf_GtLine;
  3750.                          if (XbWVMf_eof){goto end_of_read;};
  3751.                          };
  3752.                        };
  3753.                      if (XbWVMf_aP != NULL) {
  3754.                        switch ((*XbWVMf_aP)[ll].XbWVMf_T){
  3755.                          case XbWDMf_StrPar:
  3756.                            insert_string = (void  *)((*XbWVMf_aP)[ll]).XbWVMf_P;
  3757.                            break;
  3758.                          case XbWDMf_IntPar:
  3759.                            sprintf(insert_string,"%d",(int)((*XbWVMf_aP)[ll]).XbWVMf_P);
  3760.                            break;
  3761.                          case XbWDMf_DblPar:
  3762.                            sprintf(insert_string,"%s",(char *)((*XbWVMf_aP)[ll]).XbWVMf_P);
  3763.                            break;
  3764.                          case XbWDMf_VLPar:
  3765.                            {
  3766.                              XbWDDb_DbIVar  * TV;
  3767.                              TV = (XbWDDb_DbIVar  *)((*XbWVMf_aP)[ll]).XbWVMf_P;
  3768.                              insert_string = XbWFDb_GetNam(TV);
  3769.                              };
  3770.                            break;
  3771.                          };
  3772.                        }
  3773.                      else {
  3774.                        XbWFTb_Error("Not enough metafile parameters");
  3775.                        };
  3776.                    
  3777.                      ccc = 0;
  3778.                      while(insert_string[ccc] != 0){
  3779.                        cp[ii] = insert_string[ccc]; ii++;
  3780.                        ccc++;
  3781.                        };
  3782.                      };
  3783.                    /*}}}  */
  3784.                    break;
  3785.  
  3786.                  default :
  3787.                    cp[ii] = rohzeile[r_akt]; ii++;
  3788.                    r_akt++; XbWDMf_GtLine; break;
  3789.                  };
  3790.                };
  3791.              XbWVMf_P[XbWVMf_C] = (char  *)&XbWVMf_B[XbWVMf_C*XbWDMf_BfStrL];
  3792.              XbWVMf_T[XbWVMf_C] = XbWDMf_StrPar;
  3793.              XbWVMf_C++;
  3794.              XbWDMf_SekEOL;
  3795.              #ifdef TEST
  3796.                XbWFTb_Message("Stringpara fertig");
  3797.                #endif
  3798.              }
  3799.           else {
  3800.             XbWSPu_Alarm((char*)&(rohzeile[r_akt]));
  3801.             XbWVMf_eof = 1;
  3802.             goto end_of_read;
  3803.             };
  3804.           break;
  3805.  
  3806.         };
  3807. /*}}}  */
  3808.  
  3809.       if (XbWVMf_C > XbWDMf_MaxPar - 3)
  3810.         {
  3811.         XbWSPu_Alarm("Too many parameters in command...");
  3812.         return;
  3813.         };
  3814.       if (StarteProcedure == 1)
  3815.         {
  3816.         int ii;
  3817.         XbWDMf_AktPar ( *mrkpara)[];
  3818.         char fname[80];
  3819.  
  3820.         #ifdef TEST
  3821.           XbWFTb_Message("Starte Procedure...");
  3822.           #endif
  3823.  
  3824.         XbWVMf_CErr = 0;
  3825.         XbWVMf_P[XbWVMf_C] = NULL;
  3826.         XbWVMf_P[0] = (void  *)(XbWVMf_C-1);
  3827.         XbWVMf_T[0] = XbWDMf_AnzPar;
  3828.         if (!AutoMetaMode) {
  3829.           if (compile_target == 0) {
  3830.             int stat;
  3831.             stat = XbWFMf_GtComNo(ProcName);
  3832.             if (stat >= 0){
  3833.               if ((XbWVMf_Cerr = XbWFMf_ExComand(stat,0))!= 0)
  3834.                 {
  3835.                 sprintf(fname,"Sorry: %s !OK %s",ProcName,
  3836.                   XbWVMf_af);
  3837.                 XbWFTb_Error(fname);
  3838.                 };
  3839.               };
  3840.             }
  3841.           else {
  3842.             void  *pp[4];
  3843.  
  3844.             if (!AutoMetaMode) {
  3845.               pp[0] = (void  *)2;
  3846.               pp[1] = (void  *)"C";
  3847.               pp[2] = (void  *)XbWFMf_GtComNo(ProcName);
  3848.               XbWFDb_AppInt(&pp,NULL);
  3849.               pp[0] = (void  *)2;
  3850.               pp[1] = (void  *)"c";
  3851.               pp[2] = (void  *)(XbWVMf_C-1);
  3852.               XbWFDb_AppInt(&pp,NULL);
  3853.               }
  3854.             else {
  3855.               pp[0] = (void  *)2;
  3856.               pp[1] = (void  *)"M";
  3857.               pp[2] = (void  *)(ProcName);
  3858.               XbWFDb_AppStr(&pp,NULL);
  3859.               pp[0] = (void  *)2;
  3860.               pp[1] = (void  *)"c";
  3861.               pp[2] = (void  *)(XbWVMf_C);
  3862.               XbWFDb_AppInt(&pp,NULL);
  3863.               };
  3864.  
  3865.             for (ii=0;ii<XbWVMf_C;ii++) {
  3866.               switch(XbWVMf_T[ii]) {
  3867.                 case XbWDMf_StrPar:
  3868.                   pp[0] = (void  *)2;
  3869.                   pp[1] = (void  *)"";
  3870.                   pp[2] = (void *)&(XbWVMf_B[ii*XbWDMf_BfStrL]);
  3871.                   XbWFDb_AppCSt(&pp,NULL);
  3872.                   break;
  3873.                 case XbWDMf_DblPar:
  3874.                   pp[0] = (void  *)2;
  3875.                   pp[1] = (void  *)"";
  3876.                   pp[2] = (void *)&(XbWVMf_B[ii*XbWDMf_BfStrL]);
  3877.                   XbWFDb_AppDbl(&pp);
  3878.                   break;
  3879.                 case XbWDMf_IntPar:
  3880.                 case XbWDMf_VPPar:
  3881.                   pp[0] = (void  *)2;
  3882.                   pp[1] = (void  *)"";
  3883.                   pp[2] = (void *)XbWVMf_P[ii];
  3884.                   XbWFDb_AppInt(&pp,NULL);
  3885.                   break;
  3886.                 case XbWDMf_VLPar:
  3887.                   pp[0] = (void  *)2;
  3888.                   pp[1] = (void  *)"";
  3889.                   pp[2] = (void *)XbWVMf_P[ii];
  3890.                   XbWFDb_AppNPtr(&pp,NULL);
  3891.                   break;
  3892.                 case XbWDMf_VIPar:
  3893.                   pp[0] = (void  *)2;
  3894.                   pp[1] = (void  *)"";
  3895.                   pp[2] = (void *)XbWVMf_P[ii];
  3896.                   XbWFDb_AppIPtr(&pp);
  3897.                   break;
  3898.                 };
  3899.               };
  3900.             };
  3901.           }
  3902.         else
  3903.           {
  3904.           #ifdef TEST
  3905.             XbWFTb_Message("Execute Metafile...");
  3906.             #endif
  3907.           mrkpara = XbWVMf_aP;
  3908.           /*{{{  */
  3909.           if (XbWVMf_C > 1)
  3910.             /*{{{  */
  3911.             {
  3912.             XbWVMf_aP = (XbWDMf_AktPar ( *)[])XbWSSy_AlocMem(XbWVMf_C,sizeof(XbWDMf_AktPar));
  3913.             if (XbWVMf_aP != NULL)
  3914.               {
  3915.               for (ii=0;ii<XbWVMf_C;ii++)
  3916.                 {
  3917.                 if (XbWVMf_P[ii] == (char *)&(XbWVMf_B[ii*XbWDMf_BfStrL]))
  3918.                   {
  3919.                   strcpy(((*XbWVMf_aP)[ii]).Str,(char*)&(XbWVMf_B[ii*XbWDMf_BfStrL]));
  3920.                   ((*XbWVMf_aP)[ii]).XbWVMf_T = XbWVMf_T[ii];
  3921.                   ((*XbWVMf_aP)[ii]).XbWVMf_P = &(((*XbWVMf_aP)[ii]).Str);
  3922.                   }
  3923.                 else
  3924.                   {
  3925.                   ((*XbWVMf_aP)[ii]).XbWVMf_P = XbWVMf_P[ii];
  3926.                   ((*XbWVMf_aP)[ii]).XbWVMf_T = XbWVMf_T[ii];
  3927.                   };
  3928.                 };
  3929.               if (compile_target) {
  3930.                 XbWFMf_CompileMF(ProcName);
  3931.                 }
  3932.               else {
  3933.                 XbWFMf_ReadMF(ProcName);
  3934.                 };
  3935.               #ifdef TEST
  3936.                 XbWFTb_Message("Execute Metafile mit Params fertig");
  3937.                 #endif
  3938.               };
  3939.             /*}}}  */
  3940.             }
  3941.           else {
  3942.             XbWVMf_aP = NULL;
  3943.             if (compile_target) {
  3944.               XbWFMf_CompileMF(ProcName);
  3945.               }
  3946.             else {
  3947.               XbWFMf_ReadMF(ProcName);
  3948.               };
  3949.               #ifdef TEST
  3950.                 XbWFTb_Message("Execute Metafile ohne Params fertig");
  3951.                 #endif
  3952.             };
  3953.           if (XbWVMf_aP != NULL) {
  3954.             XbWSSy_FreeMem((void far*)XbWVMf_aP);
  3955.             };
  3956.           XbWVMf_aP = mrkpara;
  3957.           /*}}}  */
  3958.           };
  3959.  
  3960.         #ifdef TEST
  3961.           XbWFTb_Message("eof??");
  3962.           #endif
  3963.         if (XbWVMf_eof){
  3964.           if (strcmp(ProcName,"End") == 0) {
  3965.             goto end_of_read;
  3966.             };
  3967.           };
  3968.         #ifdef TEST
  3969.           XbWFTb_Message("error??");
  3970.           #endif
  3971.         if (XbWVMf_CErr != 0)
  3972.           {
  3973.           goto end_of_read;
  3974.           };
  3975.         StarteProcedure = 0;
  3976.         };
  3977.       if (XbWVMf_jtl == 1)
  3978.         {
  3979.         char lb[80];
  3980.         int ee=1;
  3981.         while(ee){
  3982.           r_akt++;
  3983.           XbWDMf_GtLine;
  3984.           if (XbWVMf_eof){goto end_of_read;};
  3985.           if (rohzeile[r_akt] == '!')
  3986.             {
  3987.             XbWDMf_CpyLab(lb);
  3988.             if (strstr(lb,XbWVMf_jln) == NULL)
  3989.               {
  3990.               ee=0;
  3991.               };
  3992.             };
  3993.           };
  3994.         XbWDMf_SekEOL;
  3995.         XbWVMf_jtl = 0;
  3996.         };
  3997.  
  3998.       if (r_len >0) {XbWVMf_eof = 0;};
  3999.       end_of_read:;
  4000.       };
  4001.     };
  4002.   };
  4003. /*}}}  */
  4004. /*{{{  XbWFMf_ReadMF(      ***    Metafile interpretieren*/
  4005. void  Old_Mf_ReadMF(char *filename){
  4006.   char *mrk;
  4007.   char filbuf[260];
  4008.   char thefilename[80];
  4009.   int successful = 0;
  4010.   FILE *MetaFile;
  4011.   void  *oldcursor;
  4012.  
  4013.   mrk = XbWVMf_af;
  4014.   oldcursor = XbWSMs_SetClockCursor();
  4015.   XbWVMf_mlv++;
  4016.  
  4017.   if (filename == NULL) { goto ende_ReadMF; };
  4018.  
  4019.   if (strstr(filename,".") == NULL){
  4020.     if (filename[0] == '@'){
  4021.       if (filename[1]=='('){
  4022.         sprintf(thefilename,"%s.mta",(char*)&filename[7]);
  4023.         }
  4024.       else {
  4025.         sprintf(thefilename,"%s.mta",(char*)&filename[1]);
  4026.         };
  4027.       }
  4028.     else {
  4029.       sprintf(thefilename,"%s.mta",filename);
  4030.       };
  4031.     }
  4032.   else {
  4033.     if (filename[0] == '@'){
  4034.       if (filename[1]=='('){
  4035.         sprintf(thefilename,"%s",(char*)&filename[7]);
  4036.         }
  4037.       else {
  4038.         sprintf(thefilename,"%s",(char*)&filename[1]);
  4039.         };
  4040.       }
  4041.     else {
  4042.       sprintf(thefilename,"%s",filename);
  4043.       };
  4044.     };
  4045.   MetaFile = XbWSSy_fopen(thefilename,"rb");
  4046.   if (MetaFile != NULL){ goto ReadTheFile; };
  4047.   strcpy(thefilename,filename);
  4048.  
  4049.   if (MetaFile==NULL){
  4050.     switch (filename[0]){
  4051.       case 0:   goto ende_ReadMF;
  4052.       case 'N': if (strncmp(filename,"NULL",4) == 0) {  goto ende_ReadMF; };
  4053.       default:
  4054.          sprintf(thefilename,"\\xw\\x\\%s.mta",(char*)&(filename[1]));
  4055.          MetaFile = XbWSSy_fopen(thefilename,"rb");
  4056.          if (MetaFile != NULL){ goto ReadTheFile; };
  4057.          strcpy(thefilename,filename);
  4058.          break;
  4059.       };
  4060.     };
  4061.  
  4062.   MetaFile = XbWSSy_fopen(thefilename,"rb");
  4063.   if (MetaFile == NULL) {
  4064.     switch (filename[0]){
  4065.       case '@':
  4066.         switch(filename[1]){
  4067.           case '(': break;
  4068.           default:  sprintf(thefilename,"\\xw\\x\\%s",(char*)&(filename[1]));
  4069.                     break;
  4070.           };
  4071.         break;
  4072.       default:  strcpy(thefilename,filename); break;
  4073.       };
  4074.     };
  4075.  
  4076.   if (strchr(thefilename,'.') == NULL) {
  4077.     strcat(thefilename,".mta");
  4078.     };
  4079.  
  4080.   MetaFile = XbWSSy_fopen(thefilename,"rb");
  4081.  
  4082.   if (MetaFile == NULL) {
  4083.     switch (filename[0]){
  4084.       case '@':
  4085.         sprintf(thefilename,"%s%s",XbWVSy_PrjPath,(char*)&(filename[1]));
  4086.         if (strchr(thefilename,'.') == NULL) {
  4087.           strcat(thefilename,".mta");
  4088.           };
  4089.         MetaFile = XbWSSy_fopen(thefilename,"rb");
  4090.         if (MetaFile == NULL) {
  4091.           switch (filename[0]){
  4092.             case '@':
  4093.               sprintf(thefilename,"%s%s",XbWVSy_AppPath,(char*)&(filename[1]));
  4094.               if (strchr(thefilename,'.') == NULL) {
  4095.                 strcat(thefilename,".mta");
  4096.                 };
  4097.               MetaFile = XbWSSy_fopen(thefilename,"rb");
  4098.               if (MetaFile == NULL) {
  4099.                 goto ende_ReadMF;
  4100.                 };
  4101.               break;
  4102.             default:
  4103.               goto ende_ReadMF;
  4104.             };
  4105.           };
  4106.         break;
  4107.       default:  goto ende_ReadMF;
  4108.       };
  4109.     };
  4110.  
  4111.   mrk = XbWVMf_af;
  4112.   XbWVMf_af = thefilename;
  4113.  
  4114.   #ifdef TEST
  4115.     XbWFTb_Message("Interpreter...");
  4116.     #endif
  4117. ReadTheFile:;
  4118.   XbWFMf_InterpretMF(MetaFile,filbuf,0);
  4119.   successful=1;
  4120.   XbWVMf_af= mrk;
  4121.   fclose(MetaFile);
  4122.   XbWVMf_mlv--;
  4123.   ende_ReadMF:
  4124.   XbWSMs_SetLastCursor(oldcursor);
  4125.   if (!successful){
  4126.     printf("\nERROR: Could not find metafile %s\n",filename);
  4127.     };
  4128.   };
  4129. /*}}}  */
  4130. /*{{{  XbWFMf_CompileMF(   ***    Metafile compilieren*/
  4131. void  XbWFMf_CompileMF(char *filename){
  4132.   char *mrk;
  4133.   char filbuf[260];
  4134.   char thefilename[80];
  4135.   FILE *MetaFile;
  4136.  
  4137.   void  *oldcursor;
  4138.  
  4139.   oldcursor = XbWSMs_SetClockCursor();
  4140.   XbWVMf_mlv++;
  4141.  
  4142.   if (filename == NULL) {                  goto ende_CompileMF; };
  4143.   switch (filename[0]){
  4144.     case 0:   goto ende_CompileMF;
  4145.     case 'N': if (strncmp(filename,"NULL",4) == 0) {   goto ende_CompileMF; }; break;
  4146.     case '@': sprintf(thefilename,"\\xw\\x\\%s",(char*)&(filename[1]));
  4147.               if (strchr(thefilename,';') != NULL) {
  4148.                 strcpy(strchr(thefilename,';'),"\0");
  4149.                 };
  4150.               break;
  4151.     default:  strcpy(thefilename,filename); break;
  4152.     };
  4153.  
  4154.   if (strchr(thefilename,'.') == NULL) {
  4155.     strcat(thefilename,".mta");
  4156.     };
  4157.  
  4158.   MetaFile = XbWSSy_fopen(thefilename,"rb");
  4159.  
  4160.   if (MetaFile == NULL) {
  4161.     goto ende_CompileMF;
  4162.     };
  4163.  
  4164.   mrk = XbWVMf_af;
  4165.   XbWVMf_af = thefilename;
  4166.  
  4167.   XbWFMf_InterpretMF(MetaFile,filbuf,1);
  4168.   XbWVMf_af= mrk;
  4169.   fclose(MetaFile);
  4170.   XbWVMf_mlv--;
  4171.  
  4172.   ende_CompileMF:
  4173.   XbWSMs_SetLastCursor(oldcursor);
  4174.   };
  4175. /*}}}  */
  4176. /*{{{  XbWFMf_ReadMakro(   ***    Makro interpretieren*/
  4177. void  XbWFMf_ReadMakro(char *makro){
  4178.   char *mrk;
  4179.   void  *oldcursor;
  4180.   oldcursor = XbWSMs_SetClockCursor();
  4181.   mrk = XbWVMf_af;
  4182.   XbWVMf_af = makro;
  4183. /*  XbWFMf_InterpretMF(NULL,makro,0); */
  4184.   XbWFMf_ParseMakro(makro);
  4185.   XbWVMf_af= mrk;
  4186.   XbWSMs_SetLastCursor(oldcursor);
  4187.   };
  4188. /*}}}  */
  4189.  
  4190. /*{{{  XbWFMx_DbgON(       ***    Debugging fuer MFX-Gruppen*/
  4191. void  XbWFMx_DbgON(void){
  4192.   XbWVIf_Debug = 1;
  4193.   };
  4194. /*}}}  */
  4195.  
  4196. /*{{{  XbWFSy_SysStop(     ***    XbW-System stoppen*/
  4197. void  XbWFSy_SysStop(void){
  4198.   if (XbWVDb_DbkStat == 2) {
  4199.     struct stat statbuf;
  4200.     if (fstat(XbWVDb_DbkFile,&statbuf)<0){
  4201.       printf("could not fstat() active database file.\n");
  4202.       exit(1);
  4203.       };
  4204.     munmap((caddr_t)XbWVDb_DbkStrtMem,statbuf.st_size);
  4205.     close(XbWVDb_DbkFile);
  4206.     };
  4207.  
  4208.   XbWVWd_Activ=0;
  4209.   XbWSGr_Close();
  4210.   exit(0);
  4211.   };
  4212. /*}}}  */
  4213.  
  4214. /*{{{  XbWFTb_StrExpand(   ***    Wie C: sprintf(..)*/
  4215. int  XbWFTb_StrExpand(void  *(*p)[]){
  4216.   char sstr[200];
  4217.   if ((int)((*p)[0]) < 2) {
  4218.     return(1);
  4219.     };
  4220.   switch( (int)((*p)[0])) {
  4221.     case  3: sprintf(sstr,(char*)(*p)[2], (char*)(*p)[3]); break;
  4222.     case  4: sprintf(sstr,(char*) (*p)[2], (char*) (*p)[3],
  4223.                 (char*)(*p)[4]); break;
  4224.     case  5: sprintf(sstr,(char*) (*p)[2], (char*) (*p)[3],
  4225.                 (char*)(*p)[4], (char*)(*p)[5]); break;
  4226.     case  6: sprintf(sstr,(char*) (*p)[2], (char*) (*p)[3],
  4227.                 (char*)(*p)[4], (char*)(*p)[5], (char*)(*p)[6]); break;
  4228.     case  7: sprintf(sstr,(char*) (*p)[2], (char*) (*p)[3],
  4229.                 (char*)(*p)[4], (char*)(*p)[5],
  4230.                 (char*)(*p)[6], (char*)(*p)[7]); break;
  4231.     default:return(1);
  4232.     };
  4233.   strcpy( (char*)(*p)[1],(char*)XbWFTb_PckTxt(sstr));
  4234.   return(0);
  4235.   };
  4236. /*}}}  */
  4237. /*{{{  XbWFTb_NumVal(      ***    Wie C: a=b*/
  4238. int  XbWFTb_NumVal(void  *(*p)[], int (*t)[]){
  4239.   #define SIV_a  ((int )(*p)[0])  /* Anz. Argumente             */
  4240.   #define SIV_z  ((void *)(*p)[1])  /* Ziel-Pointer (auf Integer) */
  4241.   #define SIV_o  ((char *)(*p)[2])  /* Operation (character)      */
  4242.   #define SIV_q  ((void *)(*p)[3])  /* Quelle (Integer)           */
  4243.   #define SIV_mi ((int )(*p)[4])  /* Minimum (Integer)          */
  4244.   #define SIV_ma ((int )(*p)[5])  /* Maximum (Integer)          */
  4245.  
  4246.   char *oper;
  4247.   XbWDDb_DbIVar  *QQ; XbWDDb_DbIVar  *ZZ; XbWDDb_DbIVar  *MV;
  4248.   double qv,zv,mv=0;
  4249.  
  4250.   if (SIV_a < 3) {return(1);};
  4251.   if (SIV_z == NULL) {return(1);};
  4252.  
  4253.   if ((int)(*t)[1] != XbWDMf_VLPar) { return(1); };
  4254.  
  4255.   ZZ = (XbWDDb_DbIVar  *)SIV_z;
  4256.   zv = XbWFDb_GetNum(ZZ,NULL,1);
  4257.  
  4258.   switch ((int)(*t)[3]) {
  4259.     case XbWDMf_IntPar:
  4260.       qv = (double) (int)(*p)[3];
  4261.       break;
  4262.  
  4263.     case XbWDMf_DblPar:
  4264.       qv = atof((char*)(*p)[3]);
  4265.       break;
  4266.  
  4267.     case XbWDMf_VLPar:
  4268.       if (SIV_q == NULL) {return(1);};
  4269.       QQ = (XbWDDb_DbIVar  *)SIV_q;
  4270.       qv = XbWFDb_GetNum(QQ,NULL,1);
  4271.       break;
  4272.     default:
  4273.       return(1);
  4274.     };
  4275.  
  4276.  
  4277.   oper = SIV_o;
  4278.   switch (oper[0]) {
  4279.     case '=':  XbWFDb_PutNum(ZZ,NULL,1,qv);    break;
  4280.     case '+':  XbWFDb_PutNum(ZZ,NULL,1,zv+qv); break;
  4281.     case '-':  XbWFDb_PutNum(ZZ,NULL,1,zv-qv); break;
  4282.     case '*':  XbWFDb_PutNum(ZZ,NULL,1,zv*qv); break;
  4283.     case '/':  if (qv != 0) {
  4284.                  XbWFDb_PutNum(ZZ,NULL,1,zv/qv);
  4285.                  }
  4286.                else {
  4287.                  XbWFDb_PutNum(ZZ,NULL,1,9.9E99);
  4288.                  };
  4289.                break;
  4290.     case '&':  XbWFDb_PutNum(ZZ,NULL,1,(double)((int)zv & ((int)qv)));    break;
  4291.     case '|':  XbWFDb_PutNum(ZZ,NULL,1,(double)((int)zv & ((int)qv)));    break;
  4292.     default :  return(1);
  4293.     };
  4294.  
  4295.   if (SIV_a >= 4) {
  4296.     zv = XbWFDb_GetNum(ZZ,NULL,1);
  4297.     switch ((int)(*t)[4]) {
  4298.       case XbWDMf_IntPar:
  4299.         mv = (double) (int)(*p)[4];
  4300.         break;
  4301.  
  4302.       case XbWDMf_DblPar:
  4303.         mv = atof((char*)(*p)[4]);
  4304.         break;
  4305.  
  4306.       case XbWDMf_VLPar:
  4307.         MV = (XbWDDb_DbIVar  *)SIV_mi;
  4308.         if (MV == NULL) { return(1); };
  4309.         mv = XbWFDb_GetNum(MV,NULL,1);
  4310.         break;
  4311.       };
  4312.  
  4313.     if ( zv < mv) { XbWFDb_PutNum(ZZ,NULL,1,mv); };
  4314.     };
  4315.   if (SIV_a >= 5) {
  4316.     zv = XbWFDb_GetNum(ZZ,NULL,1);
  4317.     switch ((int)(*t)[5]) {
  4318.       case XbWDMf_IntPar:
  4319.         mv = (double) (int)(*p)[5];
  4320.         break;
  4321.  
  4322.       case XbWDMf_DblPar:
  4323.         mv = atof((char*)(*p)[5]);
  4324.         break;
  4325.  
  4326.       case XbWDMf_VLPar:
  4327.         MV = (XbWDDb_DbIVar  *)SIV_ma;
  4328.         if (MV == NULL) { return(1); };
  4329.         mv = XbWFDb_GetNum(MV,NULL,1);
  4330.         break;
  4331.       };
  4332.     if ( zv > mv) { XbWFDb_PutNum(ZZ,NULL,1,mv); };
  4333.     };
  4334.   return(0);
  4335.   };
  4336. /*}}}  */
  4337.